vibe-coding-master 0.4.30 → 0.4.32

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

@@ -1,3 +1,4 @@
+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";
@@ -5,8 +6,8 @@ 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";
-const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
 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;
@@ -41,7 +42,7 @@ export function createGatewayService(deps) {
         }
         pollStartingPromise = (async () => {
             const settings = await deps.settings.loadSettings();
-            if (!settings.binding.token || isRunning()) {
+            if (!toAccount(settings) || isRunning()) {
                 return;
             }
             const controller = new AbortController();
@@ -72,14 +73,24 @@ export function createGatewayService(deps) {
             pollAbort = null;
         }
     }
+    function resolveChannel(settings) {
+        return deps.channels.get(settings.channel);
+    }
     function toAccount(settings) {
-        if (!settings.binding.token) {
+        const channel = resolveChannel(settings);
+        if (settings.channel === "weixin-ilink" && !settings.binding.token) {
+            return undefined;
+        }
+        if (settings.channel === "lark" && (!settings.binding.appId || !settings.binding.appSecret)) {
             return undefined;
         }
         return {
             accountId: settings.binding.accountId,
-            baseUrl: settings.binding.baseUrl || DEFAULT_BASE_URL,
-            token: settings.binding.token
+            baseUrl: settings.binding.baseUrl || channel.defaultBaseUrl,
+            token: settings.binding.token,
+            appId: settings.binding.appId,
+            appSecret: settings.binding.appSecret,
+            homeChatId: settings.binding.homeChatId
         };
     }
     async function pollLoop(signal) {
@@ -93,8 +104,9 @@ export function createGatewayService(deps) {
                 await savePollStatus("idle");
                 return;
             }
+            const channel = resolveChannel(settings);
             try {
-                const result = await deps.channel.getUpdates({
+                const result = await channel.getUpdates({
                     account,
                     cursor: settings.binding.getUpdatesBuf,
                     timeoutMs,
@@ -128,7 +140,7 @@ export function createGatewayService(deps) {
                 }
                 consecutiveFailures += 1;
                 const message = errorMessage(error);
-                const expired = message.toLowerCase().includes("expired");
+                const expired = channel.isSessionExpiredError?.(error) ?? message.toLowerCase().includes("expired");
                 const settingsAfterError = await deps.settings.loadSettings();
                 await deps.settings.saveSettings({
                     ...settingsAfterError,
@@ -186,25 +198,38 @@ export function createGatewayService(deps) {
             });
             return;
         }
-        settings = await deps.settings.saveSettings({
-            ...settings,
-            binding: {
-                ...settings.binding,
-                boundUserId: settings.binding.boundUserId ?? update.fromUserId,
-                contextTokens: update.contextToken
-                    ? {
-                        ...settings.binding.contextTokens,
-                        [update.fromUserId]: update.contextToken
-                    }
-                    : settings.binding.contextTokens
-            },
-            dedupe: {
-                recentInboundMessageIds: [...settings.dedupe.recentInboundMessageIds, update.messageId].slice(-1000)
-            },
-            updatedAt: now()
-        });
+        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) {
-            await reply(settings, update.fromUserId, "This VCM gateway is already bound to another Weixin DM.");
+            await reply(settings, update.fromUserId, "This VCM gateway is already bound to another user.");
             await recordMessageStatus("inbound", "ignored", update.text, "unbound user");
             return;
         }
@@ -237,6 +262,31 @@ export function createGatewayService(deps) {
             });
         }
     }
+    async function saveInboundMetadata(settings, update, options = {}) {
+        return deps.settings.saveSettings({
+            ...settings,
+            binding: {
+                ...settings.binding,
+                boundUserId: options.bindIfMissing ? settings.binding.boundUserId ?? update.fromUserId : settings.binding.boundUserId,
+                contextTokens: update.contextToken
+                    ? {
+                        ...settings.binding.contextTokens,
+                        [update.fromUserId]: update.contextToken
+                    }
+                    : settings.binding.contextTokens,
+                chatIds: update.chatId
+                    ? {
+                        ...settings.binding.chatIds,
+                        [update.fromUserId]: update.chatId
+                    }
+                    : settings.binding.chatIds
+            },
+            dedupe: {
+                recentInboundMessageIds: [...settings.dedupe.recentInboundMessageIds, update.messageId].slice(-1000)
+            },
+            updatedAt: now()
+        });
+    }
     async function executeCommand(command, settings) {
         if (!settings.enabled && !COMMANDS_ALLOWED_WHEN_DISABLED.has(command.kind)) {
             return [
@@ -581,8 +631,10 @@ export function createGatewayService(deps) {
     }
     async function startGateway() {
         const settings = await deps.settings.loadSettings();
-        if (!settings.binding.token) {
-            return "Gateway is not bound. Start QR login from desktop VCM first.";
+        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 bound. Start QR login from desktop VCM first.";
         }
         if (settings.enabled) {
             return "Gateway is already on.";
@@ -647,9 +699,11 @@ export function createGatewayService(deps) {
             return;
         }
         const contextToken = settings.binding.contextTokens[userId];
-        await deps.channel.sendText({
+        const chatId = settings.binding.chatIds[userId] ?? settings.binding.homeChatId ?? undefined;
+        await resolveChannel(settings).sendText({
             account,
             toUserId: userId,
+            chatId,
             contextToken,
             text
         });
@@ -682,6 +736,15 @@ export function createGatewayService(deps) {
             `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();
@@ -699,7 +762,7 @@ export function createGatewayService(deps) {
             if (settings.enabled) {
                 settings = await syncDesktopContext(settings);
             }
-            if (settings.binding.token) {
+            if (toAccount(settings)) {
                 await ensurePolling();
             }
             else {
@@ -713,15 +776,58 @@ 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: "Save Lark App ID and App Secret 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 login = await deps.channel.startQrLogin({
+            const channel = resolveChannel(settings);
+            if (!channel.startQrLogin) {
+                throw new VcmError({
+                    code: "GATEWAY_QR_UNSUPPORTED",
+                    message: `${channel.label} Gateway does not support QR login.`,
+                    statusCode: 409
+                });
+            }
+            const login = await channel.startQrLogin({
                 localTokenList: settings.binding.token ? [settings.binding.token] : []
             });
             qrLogin = {
+                channel: settings.channel,
                 qrcode: login.qrcode,
                 qrcodeUrl: login.qrcodeUrl,
-                baseUrl: settings.binding.baseUrl || DEFAULT_BASE_URL,
+                baseUrl: settings.binding.baseUrl || channel.defaultBaseUrl,
                 expiresAt: new Date(Date.now() + QR_LOGIN_TTL_MS).toISOString()
             };
             return {
@@ -738,7 +844,15 @@ export function createGatewayService(deps) {
                     message: "QR login expired. Start a new QR login."
                 };
             }
-            const result = await deps.channel.checkQrLogin({
+            const channel = deps.channels.get(qrLogin.channel);
+            if (!channel.checkQrLogin) {
+                throw new VcmError({
+                    code: "GATEWAY_QR_UNSUPPORTED",
+                    message: `${channel.label} Gateway does not support QR login.`,
+                    statusCode: 409
+                });
+            }
+            const result = await channel.checkQrLogin({
                 baseUrl: qrLogin.baseUrl,
                 qrcode: qrLogin.qrcode,
                 verifyCode: input.verifyCode
@@ -746,21 +860,22 @@ export function createGatewayService(deps) {
             if (result.status === "scaned_but_redirect" && result.redirectHost) {
                 qrLogin = {
                     ...qrLogin,
-                    baseUrl: normalizeBaseUrl(result.redirectHost)
+                    baseUrl: normalizeBaseUrl(result.redirectHost, channel.defaultBaseUrl)
                 };
             }
             if (result.status === "confirmed" || result.status === "binded_redirect") {
                 const settings = await deps.settings.loadSettings();
                 const token = result.token ?? settings.binding.token;
+                const boundUserId = result.boundUserId ?? result.loginUserId;
                 if (token) {
                     await deps.settings.saveSettings({
                         ...settings,
                         binding: {
                             ...settings.binding,
                             accountId: result.accountId ?? settings.binding.accountId,
-                            baseUrl: normalizeBaseUrl(result.baseUrl ?? settings.binding.baseUrl),
+                            baseUrl: normalizeBaseUrl(result.baseUrl ?? settings.binding.baseUrl, channel.defaultBaseUrl),
                             loginUserId: result.loginUserId ?? settings.binding.loginUserId,
-                            boundUserId: result.loginUserId ?? settings.binding.boundUserId,
+                            boundUserId: boundUserId ?? settings.binding.boundUserId,
                             token
                         },
                         updatedAt: now()
@@ -769,11 +884,12 @@ export function createGatewayService(deps) {
                     await ensurePolling();
                 }
             }
+            const boundUserId = result.boundUserId ?? result.loginUserId;
             return {
                 status: result.status,
                 qrcodeUrl: qrLogin?.qrcodeUrl,
                 accountId: result.accountId,
-                boundUserId: result.loginUserId,
+                boundUserId,
                 loginUserId: result.loginUserId
             };
         },
@@ -812,9 +928,10 @@ export function createGatewayService(deps) {
                 taskSlug: input.taskSlug,
                 sourceText: text
             });
-            await deps.channel.sendText({
+            await resolveChannel(settings).sendText({
                 account,
                 toUserId: boundUserId,
+                chatId: settings.binding.chatIds[boundUserId] ?? settings.binding.homeChatId ?? undefined,
                 contextToken: settings.binding.contextTokens[boundUserId],
                 text: output.text
             });
@@ -1095,6 +1212,14 @@ 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) {
@@ -1108,10 +1233,10 @@ function sleep(ms, signal) {
         }, { once: true });
     });
 }
-function normalizeBaseUrl(input) {
+function normalizeBaseUrl(input, fallback) {
     const trimmed = input.trim();
     if (!trimmed) {
-        return DEFAULT_BASE_URL;
+        return fallback;
     }
     if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
         return trimmed.replace(/\/+$/, "");

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

@@ -1,27 +1,32 @@
 import path from "node:path";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+const DEFAULT_GATEWAY_CHANNEL = "weixin-ilink";
 const MAX_DEDUPE_IDS = 1000;
 export function createGatewaySettingsService(deps) {
     const dataDir = resolveVcmDataDir();
     const settingsPath = deps.settingsPath ?? path.join(dataDir, "gateway", "settings.json");
     const auditPath = deps.auditPath ?? path.join(dataDir, "gateway", "audit.jsonl");
     const now = deps.now ?? (() => new Date().toISOString());
+    const normalizeOptions = {
+        defaultChannel: deps.defaultChannel ?? DEFAULT_GATEWAY_CHANNEL,
+        defaultBaseUrl: deps.defaultBaseUrl ?? DEFAULT_BASE_URL
+    };
     let cachedSettings = null;
     async function loadSettings() {
         if (cachedSettings) {
             return cachedSettings;
         }
         if (!(await deps.fs.pathExists(settingsPath))) {
-            cachedSettings = normalizeSettings({}, now());
+            cachedSettings = normalizeSettings({}, now(), normalizeOptions);
             await saveSettings(cachedSettings);
             return cachedSettings;
         }
-        cachedSettings = normalizeSettings(await deps.fs.readJson(settingsPath), now());
+        cachedSettings = normalizeSettings(await deps.fs.readJson(settingsPath), now(), normalizeOptions);
         return cachedSettings;
     }
     async function saveSettings(settings) {
-        cachedSettings = normalizeSettings(settings, now());
+        cachedSettings = normalizeSettings(settings, now(), normalizeOptions);
         await deps.fs.writeJsonAtomic(settingsPath, cachedSettings);
         return cachedSettings;
     }
@@ -32,9 +37,19 @@ export function createGatewaySettingsService(deps) {
             return saveSettings({
                 ...current,
                 enabled: input.enabled ?? current.enabled,
+                channel: input.channel ?? current.channel,
                 translationEnabled: input.translationEnabled ?? current.translationEnabled,
                 currentProjectId: input.currentProjectId !== undefined ? normalizeNullableString(input.currentProjectId) : current.currentProjectId,
                 currentTaskSlug: input.currentTaskSlug !== undefined ? normalizeNullableString(input.currentTaskSlug) : current.currentTaskSlug,
+                binding: {
+                    ...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
+                },
                 updatedAt: now()
             });
         },
@@ -44,7 +59,13 @@ export function createGatewaySettingsService(deps) {
             return saveSettings({
                 ...current,
                 enabled: false,
-                binding: createDefaultBinding(),
+                binding: {
+                    ...createDefaultBinding(normalizeOptions.defaultBaseUrl),
+                    baseUrl: current.binding.baseUrl || normalizeOptions.defaultBaseUrl,
+                    appId: current.binding.appId,
+                    appSecret: current.binding.appSecret,
+                    homeChatId: current.binding.homeChatId
+                },
                 dedupe: {
                     recentInboundMessageIds: []
                 },
@@ -71,7 +92,12 @@ export function createGatewaySettingsService(deps) {
                     baseUrl: settings.binding.baseUrl,
                     boundUserId: settings.binding.boundUserId,
                     loginUserId: settings.binding.loginUserId,
-                    tokenConfigured: Boolean(settings.binding.token)
+                    tokenConfigured: Boolean(settings.binding.token),
+                    appId: settings.binding.appId,
+                    appIdConfigured: Boolean(settings.binding.appId),
+                    appSecretConfigured: Boolean(settings.binding.appSecret),
+                    homeChatId: settings.binding.homeChatId,
+                    pairingCodeExpiresAt: settings.binding.pairingCodeExpiresAt
                 },
                 pendingConfirmations: settings.pendingConfirmations,
                 lastPollStatus: settings.lastPollStatus,
@@ -87,7 +113,10 @@ export function createGatewaySettingsService(deps) {
         }
     };
 }
-export function normalizeSettings(input, timestamp) {
+export function normalizeSettings(input, timestamp, options = {
+    defaultChannel: DEFAULT_GATEWAY_CHANNEL,
+    defaultBaseUrl: DEFAULT_BASE_URL
+}) {
     const bindingInput = isObject(input.binding) ? input.binding : {};
     const dedupeInput = isObject(input.dedupe) ? input.dedupe : {};
     const pendingInput = isObject(input.pendingConfirmations)
@@ -100,20 +129,28 @@ export function normalizeSettings(input, timestamp) {
     return {
         version: 1,
         enabled: input.enabled === true,
-        channel: "weixin-ilink",
+        channel: normalizeGatewayChannel(input.channel, options.defaultChannel),
         translationEnabled: input.translationEnabled !== false,
         currentProjectId: normalizeNullableString(input.currentProjectId),
         currentTaskSlug: normalizeNullableString(input.currentTaskSlug),
         binding: {
-            ...createDefaultBinding(),
+            ...createDefaultBinding(options.defaultBaseUrl),
             accountId: normalizeNullableString(bindingInput.accountId),
-            baseUrl: normalizeBaseUrl(bindingInput.baseUrl),
+            baseUrl: normalizeBaseUrl(bindingInput.baseUrl, options.defaultBaseUrl),
             boundUserId: normalizeNullableString(bindingInput.boundUserId),
             loginUserId: normalizeNullableString(bindingInput.loginUserId),
             token: normalizeNullableString(bindingInput.token),
+            appId: normalizeNullableString(bindingInput.appId),
+            appSecret: normalizeNullableString(bindingInput.appSecret),
+            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)
+                : {},
+            chatIds: isObject(bindingInput.chatIds)
+                ? normalizeStringRecord(bindingInput.chatIds)
                 : {}
         },
         dedupe: {
@@ -131,17 +168,26 @@ export function normalizeSettings(input, timestamp) {
         updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : timestamp
     };
 }
-function createDefaultBinding() {
+function createDefaultBinding(defaultBaseUrl = DEFAULT_BASE_URL) {
     return {
         accountId: null,
-        baseUrl: DEFAULT_BASE_URL,
+        baseUrl: defaultBaseUrl,
         boundUserId: null,
         loginUserId: null,
         token: null,
+        appId: null,
+        appSecret: null,
+        homeChatId: null,
+        pairingCode: null,
+        pairingCodeExpiresAt: null,
         getUpdatesBuf: "",
-        contextTokens: {}
+        contextTokens: {},
+        chatIds: {}
     };
 }
+function normalizeGatewayChannel(input, fallback) {
+    return input === "weixin-ilink" || input === "lark" ? input : fallback;
+}
 function normalizeCloseTaskConfirmation(input) {
     if (!isObject(input)) {
         return null;
@@ -222,10 +268,10 @@ function normalizeMessageStatus(input) {
         error: normalizeNullableString(input.error) ?? undefined
     };
 }
-function normalizeBaseUrl(input) {
+function normalizeBaseUrl(input, fallback = DEFAULT_BASE_URL) {
     const raw = typeof input === "string" ? input.trim() : "";
     if (!raw) {
-        return DEFAULT_BASE_URL;
+        return fallback;
     }
     if (raw.startsWith("http://") || raw.startsWith("https://")) {
         return raw.replace(/\/+$/, "");

package/dist/backend/server.js

@@ -18,8 +18,10 @@ import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
 import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
 import { registerGatewayRoutes } from "./api/gateway-routes.js";
 import { registerDiagnosticsRoutes } from "./api/diagnostics-routes.js";
+import { createLarkChannel } from "./gateway/channels/lark-channel.js";
 import { createWeixinIlinkChannel } from "./gateway/channels/weixin-ilink-channel.js";
 import { createGatewayAuditLog } from "./gateway/gateway-audit-log.js";
+import { createGatewayChannelRegistry } from "./gateway/gateway-channel.js";
 import { createGatewayService } from "./gateway/gateway-service.js";
 import { createGatewaySettingsService } from "./gateway/gateway-settings-service.js";
 import { createJobGuardService } from "./services/job-guard-service.js";
@@ -261,7 +263,15 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         appSettings
     });
-    const gatewaySettings = createGatewaySettingsService({ fs });
+    const gatewayChannels = createGatewayChannelRegistry([
+        createWeixinIlinkChannel(),
+        createLarkChannel()
+    ]);
+    const gatewaySettings = createGatewaySettingsService({
+        fs,
+        defaultChannel: gatewayChannels.defaultChannel.id,
+        defaultBaseUrl: gatewayChannels.defaultChannel.defaultBaseUrl
+    });
     const gatewayAudit = createGatewayAuditLog({
         fs,
         auditPath: gatewaySettings.getAuditPath()
@@ -270,7 +280,7 @@ export function createDefaultServerDeps(options = {}) {
         fs,
         settings: gatewaySettings,
         audit: gatewayAudit,
-        channel: createWeixinIlinkChannel(),
+        channels: gatewayChannels,
         projectService,
         taskService,
         sessionService,

package/dist/backend/services/harness-service.js

@@ -266,6 +266,9 @@ export function createHarnessService(deps) {
         async getRepositoryDiff(repoRoot, input = {}) {
             return getRepositoryDiffReport(requireRepositoryDiffGit(deps.git), repoRoot, input, now());
         },
+        async getRepositoryFileDiff(repoRoot, input) {
+            return getRepositoryFileDiffReport(requireRepositoryDiffGit(deps.git), repoRoot, input, now());
+        },
         async mergeRepositoryDiffToCurrentBranch(baseRepoRoot, input) {
             return mergeRepositoryDiffToCurrentBranch(requireRepositoryMergeGit(deps.git), baseRepoRoot, input, now());
         },
@@ -466,6 +469,7 @@ function requireRepositoryDiffGit(git) {
         !git.getCommitInfo ||
         !git.getCommitList ||
         !git.getCurrentBranch ||
+        !git.getDiff ||
         !git.getHeadCommit ||
         !git.getMergeBase) {
         throw new VcmError({
@@ -550,6 +554,34 @@ async function getRepositoryDiffReport(git, repoRoot, input, generatedAt) {
         warnings
     };
 }
+async function getRepositoryFileDiffReport(git, repoRoot, input, generatedAt) {
+    const filePath = normalizeHarnessGitPath(input.path);
+    const baseRepoRoot = input.baseRepoRoot;
+    const sourceBranch = await git.getCurrentBranch(repoRoot);
+    const targetBranch = await git.getCurrentBranch(baseRepoRoot);
+    const baseSha = await git.getHeadCommit(baseRepoRoot);
+    const headSha = await git.getHeadCommit(repoRoot);
+    const rawDiff = await git.getDiff(repoRoot, baseSha, null, [filePath]);
+    const files = parseCommitDiffFiles(rawDiff);
+    const file = files.find((entry) => entry.path === filePath || entry.oldPath === filePath) ?? files[0] ?? null;
+    const warnings = [];
+    if (files.length > 1) {
+        warnings.push(`Multiple diff entries matched ${filePath}; showing the first entry.`);
+    }
+    return {
+        version: 1,
+        repoRoot,
+        baseRepoRoot,
+        sourceBranch,
+        targetBranch,
+        baseSha,
+        headSha,
+        path: filePath,
+        generatedAt,
+        file,
+        warnings
+    };
+}
 async function mergeRepositoryDiffToCurrentBranch(git, baseRepoRoot, input, mergedAt) {
     const taskBranch = input.taskBranch.trim();
     if (!taskBranch) {