@researai/deepscientist 1.5.13 → 1.5.15

package/src/tui/dist/app/AppContainer.js

@@ -3,9 +3,29 @@ import fs from 'node:fs';
 import { useApp, useInput } from 'ink';
 import { spawn } from 'node:child_process';
 import { client } from '../lib/api.js';
+import { CONNECTOR_ORDER, connectorLabel, connectorSubtitle, createLingzhuAk, looksLikeWeixinQrImageUrl, resolveLingzhuAuthAk, supportsGuidedConnector, } from '../lib/connectorConfig.js';
+import { connectorTargetLabel, normalizeConnectorTargets, qqProfileDisplayLabel, qqProfileStatus, selectQqProfileTarget, } from '../lib/connectors.js';
+import { renderQrAscii } from '../lib/qr.js';
 import { buildToolOperationContent, extractToolSubject } from '../lib/toolOperations.js';
 import { DefaultAppLayout } from '../layouts/DefaultAppLayout.js';
 const LOCAL_USER_SOURCE = 'tui-local';
+const CONFIG_ROOT_ENTRIES = [
+    {
+        id: 'connectors',
+        title: 'Connectors',
+        description: 'Choose QQ, Weixin, Lingzhu, or another connector and configure it with arrows plus Enter.',
+    },
+    {
+        id: 'global-files',
+        title: 'Global Config Files',
+        description: 'Open raw runtime config files such as config.yaml, runners.yaml, and connectors.yaml.',
+    },
+    {
+        id: 'quest-files',
+        title: 'Current Quest Files',
+        description: 'Open quest-local config files for the currently selected quest.',
+    },
+];
 const buildId = (prefix, raw) => `${prefix}:${raw}`;
 const stringifyStructured = (value) => {
     if (typeof value === 'string') {
@@ -107,6 +127,130 @@ const resolveConfigTarget = (token, items) => {
     }
     return (items.find((item) => item.name === trimmed || item.title === trimmed || item.configName === trimmed) ?? null);
 };
+const resolveManagedConnectorName = (token) => {
+    const normalized = String(token || '').trim().toLowerCase();
+    if (!normalized) {
+        return null;
+    }
+    if (CONNECTOR_ORDER.includes(normalized)) {
+        return normalized;
+    }
+    if (normalized === 'wechat') {
+        return 'weixin';
+    }
+    return null;
+};
+const connectorNamesFromStructuredConfig = (structured) => {
+    const known = new Set();
+    for (const name of CONNECTOR_ORDER) {
+        if (structured && typeof structured[name] === 'object') {
+            known.add(name);
+        }
+    }
+    return CONNECTOR_ORDER.filter((name) => known.has(name));
+};
+const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+const cloneStructured = (value) => {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return { ...value };
+    }
+};
+const displayBoolean = (value) => (Boolean(value) ? 'on' : 'off');
+const displayMaybeString = (value) => {
+    const text = String(value ?? '').trim();
+    return text || '—';
+};
+const CONNECTOR_BIND_ACTION_PREFIX = 'bind-target:';
+const CONNECTOR_UNBIND_ACTION_PREFIX = 'unbind-target:';
+const LINGZHU_PUBLIC_AGENT_ID = 'DeepScientist';
+const LINGZHU_PLATFORM_AGENT_NAME = 'DeepScientist';
+const LINGZHU_PLATFORM_CATEGORY = 'Work';
+const LINGZHU_PLATFORM_INPUT_TYPE = 'Text';
+const LINGZHU_PLATFORM_CAPABILITY_SUMMARY = 'DeepScientist is a local-first research agent for planning, experiments, analysis, writing, and execution follow-up.';
+const LINGZHU_PLATFORM_OPENING_MESSAGE = 'Hello, I am DeepScientist. Tell me the research goal, experiment question, or task you want to move forward.';
+const LINGZHU_PLATFORM_LOGO_PATH = '/assets/branding/logo-rokid.png';
+const normalizedText = (value) => String(value ?? '').trim();
+const normalizeBaseUrl = (value) => {
+    const text = normalizedText(value);
+    return text ? text.replace(/\/+$/, '') : '';
+};
+const looksLikePublicBaseUrl = (value) => {
+    const text = normalizeBaseUrl(value);
+    if (!text) {
+        return false;
+    }
+    try {
+        const url = new URL(text);
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            return false;
+        }
+        const host = url.hostname.trim().toLowerCase();
+        if (!host || ['localhost', '0.0.0.0', '127.0.0.1', '::1'].includes(host) || host.endsWith('.local')) {
+            return false;
+        }
+        if (/^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[0-1])\./.test(host)) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const lingzhuPublicSseUrl = (config, details) => {
+    const detailValue = normalizeBaseUrl(details.public_endpoint_url);
+    if (detailValue) {
+        return detailValue;
+    }
+    const base = normalizeBaseUrl(config.public_base_url);
+    return base ? `${base}/metis/agent/api/sse` : '';
+};
+const lingzhuPublicHealthUrl = (config, details) => {
+    const detailValue = normalizeBaseUrl(details.public_health_url);
+    if (detailValue) {
+        return detailValue;
+    }
+    const base = normalizeBaseUrl(config.public_base_url);
+    return base ? `${base}/metis/agent/api/health` : '';
+};
+const lingzhuPlatformLogoUrl = (baseUrl) => {
+    try {
+        const url = new URL(baseUrl);
+        if (url.hostname === '0.0.0.0') {
+            url.hostname = '127.0.0.1';
+        }
+        return new URL(LINGZHU_PLATFORM_LOGO_PATH, url.origin).toString();
+    }
+    catch {
+        return LINGZHU_PLATFORM_LOGO_PATH;
+    }
+};
+const buildConnectorBindActionId = (connectorName, conversationId) => `${CONNECTOR_BIND_ACTION_PREFIX}${connectorName}:${encodeURIComponent(conversationId)}`;
+const parseConnectorBindActionId = (actionId) => {
+    if (!actionId.startsWith(CONNECTOR_BIND_ACTION_PREFIX)) {
+        return null;
+    }
+    const payload = actionId.slice(CONNECTOR_BIND_ACTION_PREFIX.length);
+    const separator = payload.indexOf(':');
+    if (separator < 0) {
+        return null;
+    }
+    return {
+        connectorName: payload.slice(0, separator),
+        conversationId: decodeURIComponent(payload.slice(separator + 1)),
+    };
+};
+const buildConnectorUnbindActionId = (connectorName) => `${CONNECTOR_UNBIND_ACTION_PREFIX}${connectorName}`;
+const parseConnectorUnbindActionId = (actionId) => {
+    if (!actionId.startsWith(CONNECTOR_UNBIND_ACTION_PREFIX)) {
+        return null;
+    }
+    const connectorName = actionId.slice(CONNECTOR_UNBIND_ACTION_PREFIX.length).trim();
+    return connectorName ? connectorName : null;
+};
 function normalizeUpdate(raw) {
     const eventType = String(raw.event_type ?? '');
     const data = (raw.data ?? {});
@@ -363,10 +507,15 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
     const [connectors, setConnectors] = useState([]);
     const [activeQuestId, setActiveQuestId] = useState(initialQuestId);
     const [browseQuestId, setBrowseQuestId] = useState(initialQuestId);
-    const [configMode, setConfigMode] = useState(null);
+    const [configView, setConfigView] = useState(null);
     const [configItems, setConfigItems] = useState([]);
     const [configIndex, setConfigIndex] = useState(0);
+    const [configSectionTitle, setConfigSectionTitle] = useState('Config');
+    const [configSectionDescription, setConfigSectionDescription] = useState('');
     const [configEditor, setConfigEditor] = useState(null);
+    const [connectorsDocument, setConnectorsDocument] = useState(null);
+    const [selectedConnectorName, setSelectedConnectorName] = useState(null);
+    const [weixinQrState, setWeixinQrState] = useState(null);
     const [questPanelMode, setQuestPanelMode] = useState(null);
     const [questPanelIndex, setQuestPanelIndex] = useState(0);
     const [session, setSession] = useState(null);
@@ -387,7 +536,631 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
     const activeQuest = useMemo(() => quests.find((quest) => quest.quest_id === activeQuestId) ?? null, [quests, activeQuestId]);
     const browseQuest = useMemo(() => quests.find((quest) => quest.quest_id === browseQuestId) ?? null, [quests, browseQuestId]);
     const panelQuests = useMemo(() => (questPanelMode ? getPanelQuests(questPanelMode, quests) : []), [questPanelMode, quests]);
+    const configMode = useMemo(() => (configView ? (configEditor ? 'edit' : 'browse') : null), [configEditor, configView]);
     const selectedQuestForConfig = useMemo(() => activeQuest ?? browseQuest ?? null, [activeQuest, browseQuest]);
+    const selectedConnectorSnapshot = useMemo(() => selectedConnectorName
+        ? connectors.find((item) => String(item.name || '').trim().toLowerCase() === selectedConnectorName) ?? null
+        : null, [connectors, selectedConnectorName]);
+    const selectedConnectorConfig = useMemo(() => (selectedConnectorName ? asRecord(connectorsDocument?.structured?.[selectedConnectorName]) : {}), [connectorsDocument?.structured, selectedConnectorName]);
+    const connectorMenuEntries = useMemo(() => {
+        const configuredNames = connectorNamesFromStructuredConfig(connectorsDocument?.structured ?? null);
+        const names = configuredNames.length > 0 ? configuredNames : CONNECTOR_ORDER;
+        return names.map((name) => {
+            const snapshot = connectors.find((item) => String(item.name || '').trim().toLowerCase() === name) ?? null;
+            return {
+                name,
+                label: connectorLabel(name),
+                subtitle: connectorSubtitle(name),
+                enabled: snapshot?.enabled !== false && Boolean(snapshot?.enabled || asRecord(connectorsDocument?.structured?.[name]).enabled),
+                connectionState: snapshot?.connection_state || snapshot?.auth_state || 'idle',
+                bindingCount: snapshot?.binding_count,
+                targetCount: snapshot?.target_count,
+                supportMode: supportsGuidedConnector(name) ? 'guided' : 'raw',
+            };
+        });
+    }, [connectors, connectorsDocument?.structured]);
+    const qqHasMultipleProfiles = useMemo(() => {
+        const profiles = selectedConnectorName === 'qq' ? selectedConnectorConfig.profiles : null;
+        return Array.isArray(profiles) && profiles.length > 1;
+    }, [selectedConnectorConfig, selectedConnectorName]);
+    const selectedConnectorTargets = useMemo(() => (selectedConnectorSnapshot ? normalizeConnectorTargets(selectedConnectorSnapshot) : []), [selectedConnectorSnapshot]);
+    const qqProfileSummaries = useMemo(() => {
+        if (selectedConnectorName !== 'qq') {
+            return [];
+        }
+        const configuredProfiles = Array.isArray(selectedConnectorConfig.profiles)
+            ? selectedConnectorConfig.profiles
+                .filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+                .map((item) => asRecord(item))
+            : [];
+        const runtimeProfiles = Array.isArray(selectedConnectorSnapshot?.profiles) ? selectedConnectorSnapshot.profiles : [];
+        const runtimeById = new Map(runtimeProfiles.map((profile) => [normalizedText(profile.profile_id), profile]));
+        const totalProfiles = configuredProfiles.length;
+        return configuredProfiles.map((profile, index) => {
+            const profileId = normalizedText(profile.profile_id || `qq-profile-${index + 1}`);
+            const runtime = runtimeById.get(profileId);
+            const profileTargets = selectedConnectorTargets.filter((target) => {
+                const targetProfileId = normalizedText(target.profile_id);
+                if (targetProfileId) {
+                    return targetProfileId === profileId;
+                }
+                return totalProfiles === 1;
+            });
+            const mainChatId = normalizedText(profile.main_chat_id || runtime?.main_chat_id);
+            const selectedTarget = selectQqProfileTarget(profileTargets, mainChatId);
+            return {
+                profileId,
+                label: qqProfileDisplayLabel({
+                    profile_id: profileId,
+                    bot_name: normalizedText(profile.bot_name) || undefined,
+                    app_id: normalizedText(profile.app_id) || undefined,
+                }, runtime ?? null),
+                appId: normalizedText(profile.app_id || runtime?.app_id),
+                mainChatId,
+                lastConversationId: normalizedText(runtime?.last_conversation_id),
+                targetCount: profileTargets.length,
+                selectedTarget,
+                status: qqProfileStatus(runtime ?? null, profileTargets, mainChatId),
+            };
+        });
+    }, [selectedConnectorConfig.profiles, selectedConnectorName, selectedConnectorSnapshot?.profiles, selectedConnectorTargets]);
+    const connectorContextLine = useMemo(() => {
+        if (selectedQuestForConfig?.quest_id) {
+            return `Current quest for binding: ${selectedQuestForConfig.quest_id}`;
+        }
+        return 'No active quest selected yet. You can still save connector settings.';
+    }, [selectedQuestForConfig?.quest_id]);
+    const connectorGuideSections = useMemo(() => {
+        if (!selectedConnectorName) {
+            return [];
+        }
+        if (selectedConnectorName === 'weixin') {
+            const accountId = normalizedText(selectedConnectorConfig.account_id || selectedConnectorSnapshot?.details?.account_id);
+            const loginUserId = normalizedText(selectedConnectorConfig.login_user_id);
+            const hasBinding = Boolean(accountId);
+            return [
+                {
+                    id: 'weixin-flow',
+                    title: 'Top Guide',
+                    tone: hasBinding ? 'success' : 'info',
+                    lines: [
+                        '1. Choose Bind/Rebind Weixin to create a QR code inside TUI.',
+                        '2. Scan the QR code with the WeChat app on the phone that owns this account, then confirm the login in WeChat.',
+                        '3. DeepScientist saves the binding automatically and returns here after confirmation.',
+                    ],
+                },
+                {
+                    id: 'weixin-status',
+                    title: 'Current Status',
+                    tone: hasBinding ? 'success' : 'warning',
+                    lines: [
+                        `Bot account: ${accountId || 'not bound yet'}`,
+                        `Owner account: ${loginUserId || 'not bound yet'}`,
+                        `Known targets: ${selectedConnectorTargets.length || selectedConnectorSnapshot?.target_count || 0}`,
+                    ],
+                },
+            ];
+        }
+        if (selectedConnectorName === 'lingzhu') {
+            const details = asRecord(selectedConnectorSnapshot?.details);
+            const authAk = normalizedText(resolveLingzhuAuthAk(selectedConnectorConfig.auth_ak));
+            const publicBaseUrl = normalizeBaseUrl(selectedConnectorConfig.public_base_url);
+            const publicSseUrl = normalizedText(lingzhuPublicSseUrl(selectedConnectorConfig, details));
+            const publicReady = looksLikePublicBaseUrl(publicBaseUrl);
+            const tone = publicReady && authAk ? 'success' : 'warning';
+            return [
+                {
+                    id: 'lingzhu-flow',
+                    title: 'Top Guide',
+                    tone,
+                    lines: [
+                        '1. Set Public base URL to the final public DeepScientist origin before binding a real Rokid device.',
+                        '2. Copy the generated Rokid fields below into the platform exactly as shown, including Custom agent ID, URL, AK, Agent name, Category, Capability summary, Opening message, and Input type.',
+                        '3. After the Rokid form is filled on the platform, return here and run Save Connector.',
+                    ],
+                },
+                {
+                    id: 'lingzhu-platform',
+                    title: 'Generated For Rokid',
+                    tone,
+                    lines: [
+                        `Custom agent ID: ${normalizedText(selectedConnectorConfig.agent_id || LINGZHU_PUBLIC_AGENT_ID) || LINGZHU_PUBLIC_AGENT_ID}`,
+                        `Custom agent URL: ${publicSseUrl || 'set Public base URL first'}`,
+                        `Custom agent AK: ${authAk || 'generate or fill Custom agent AK first'}`,
+                        `Agent name: ${LINGZHU_PLATFORM_AGENT_NAME}`,
+                        `Category: ${LINGZHU_PLATFORM_CATEGORY}`,
+                        `Capability summary: ${LINGZHU_PLATFORM_CAPABILITY_SUMMARY}`,
+                        `Opening message: ${LINGZHU_PLATFORM_OPENING_MESSAGE}`,
+                        `Input type: ${LINGZHU_PLATFORM_INPUT_TYPE}`,
+                    ],
+                },
+                ...(publicReady
+                    ? []
+                    : [
+                        {
+                            id: 'lingzhu-warning',
+                            title: 'Public URL Required',
+                            tone: 'warning',
+                            lines: ['The current Public base URL is not a public HTTP(S) address yet, so Rokid devices will not be able to reach this bridge.'],
+                        },
+                    ]),
+            ];
+        }
+        if (selectedConnectorName === 'qq') {
+            const detectedOpenId = normalizedText(selectedConnectorConfig.main_chat_id || selectedConnectorSnapshot?.main_chat_id);
+            const lastConversationId = normalizedText(selectedConnectorSnapshot?.last_conversation_id);
+            const hasCredentials = Boolean(normalizedText(selectedConnectorConfig.app_id) && normalizedText(selectedConnectorConfig.app_secret));
+            const hasDetectedTarget = Boolean(detectedOpenId || selectedConnectorTargets.length);
+            const tone = hasDetectedTarget ? 'success' : hasCredentials ? 'warning' : 'info';
+            return [
+                {
+                    id: 'qq-flow',
+                    title: 'Top Guide',
+                    tone,
+                    lines: [
+                        '1. Create the bot in the official QQ Bot Platform and copy App ID plus App Secret.',
+                        qqHasMultipleProfiles
+                            ? '2. Multiple QQ profiles are configured. The TUI shows each profile status below, and you can still bind runtime targets here. Use raw connectors.yaml only for adding, deleting, or replacing profile credentials.'
+                            : '2. Fill Bot name, App ID, and App Secret below, then run Save Connector.',
+                        hasDetectedTarget
+                            ? '3. OpenID and conversation targets are already visible below. Bind the current quest to the correct target.'
+                            : '3. After saving, send one private QQ message to the bot. TUI auto-refreshes Detected OpenID and conversation_id from runtime activity.',
+                    ],
+                },
+                {
+                    id: 'qq-status',
+                    title: 'Current Status',
+                    tone,
+                    lines: [
+                        `Detected OpenID: ${detectedOpenId || 'waiting for first private message'}`,
+                        `Last conversation: ${lastConversationId || 'waiting for runtime activity'}`,
+                        `Configured profiles: ${qqProfileSummaries.length || 0}`,
+                        `Discovered targets: ${selectedConnectorTargets.length}`,
+                    ],
+                },
+                ...(!selectedQuestForConfig?.quest_id && hasDetectedTarget
+                    ? [
+                        {
+                            id: 'qq-bind-warning',
+                            title: 'Quest Binding Needs A Quest',
+                            tone: 'warning',
+                            lines: ['Open a quest with `/use <quest_id>` first, then come back here to bind the detected QQ target to that quest.'],
+                        },
+                    ]
+                    : []),
+            ];
+        }
+        return [];
+    }, [
+        qqProfileSummaries.length,
+        qqHasMultipleProfiles,
+        selectedConnectorConfig,
+        selectedConnectorName,
+        selectedConnectorSnapshot,
+        selectedConnectorTargets,
+        selectedQuestForConfig?.quest_id,
+    ]);
+    const connectorDetailItems = useMemo(() => {
+        if (!selectedConnectorName) {
+            return [];
+        }
+        const activeBindingQuestId = selectedQuestForConfig?.quest_id || null;
+        const currentQuestTarget = activeBindingQuestId
+            ? selectedConnectorTargets.find((item) => normalizedText(item.bound_quest_id) === activeBindingQuestId) || null
+            : null;
+        const bindingActionItems = [];
+        if (activeBindingQuestId && currentQuestTarget) {
+            bindingActionItems.push({
+                type: 'action',
+                id: buildConnectorUnbindActionId(selectedConnectorName),
+                label: `Unbind ${activeBindingQuestId}`,
+                description: `Remove ${activeBindingQuestId} from ${connectorLabel(selectedConnectorName)} and return the quest to local-only binding.`,
+            });
+        }
+        if (activeBindingQuestId) {
+            for (const target of selectedConnectorTargets) {
+                const targetLabel = connectorTargetLabel(target) || target.conversation_id;
+                const bindingState = normalizedText(target.bound_quest_id) === activeBindingQuestId
+                    ? `Already bound to ${activeBindingQuestId}.`
+                    : normalizedText(target.bound_quest_id)
+                        ? `Currently bound to ${target.bound_quest_id}. Enter will rebind it to ${activeBindingQuestId}.`
+                        : `Not bound yet. Enter will bind it to ${activeBindingQuestId}.`;
+                bindingActionItems.push({
+                    type: 'action',
+                    id: buildConnectorBindActionId(selectedConnectorName, target.conversation_id),
+                    label: `Bind ${targetLabel}`,
+                    description: `${target.conversation_id} · ${bindingState}`,
+                });
+            }
+        }
+        if (selectedConnectorName === 'weixin') {
+            return [
+                {
+                    type: 'action',
+                    id: 'weixin-start-login',
+                    label: selectedConnectorSnapshot?.enabled ? 'Rebind Weixin' : 'Bind Weixin',
+                    description: 'Start QR login, render a QR code in TUI, and save the connector automatically after confirmation.',
+                },
+                {
+                    type: 'action',
+                    id: 'refresh-connector',
+                    label: 'Refresh Status',
+                    description: 'Reload connector runtime snapshot and current structured config.',
+                },
+                {
+                    type: 'info',
+                    id: 'weixin-account-id',
+                    label: 'Bot account',
+                    value: displayMaybeString(selectedConnectorConfig.account_id ?? selectedConnectorSnapshot?.details?.account_id),
+                    description: 'Saved Weixin bot account id.',
+                },
+                {
+                    type: 'info',
+                    id: 'weixin-login-user',
+                    label: 'Owner account',
+                    value: displayMaybeString(selectedConnectorConfig.login_user_id),
+                    description: 'WeChat account that confirmed the QR login.',
+                },
+                {
+                    type: 'info',
+                    id: 'weixin-base-url',
+                    label: 'Base URL',
+                    value: displayMaybeString(selectedConnectorConfig.base_url),
+                    description: 'The iLink API base URL saved in connectors config.',
+                },
+                {
+                    type: 'info',
+                    id: 'weixin-targets',
+                    label: 'Known targets',
+                    value: String(selectedConnectorTargets.length || selectedConnectorSnapshot?.target_count || 0),
+                    description: 'Targets discovered by the Weixin connector.',
+                },
+                ...bindingActionItems,
+            ];
+        }
+        if (selectedConnectorName === 'lingzhu') {
+            const details = asRecord(selectedConnectorSnapshot?.details);
+            const authAk = resolveLingzhuAuthAk(selectedConnectorConfig.auth_ak);
+            const publicReady = looksLikePublicBaseUrl(selectedConnectorConfig.public_base_url);
+            const publicSseUrl = lingzhuPublicSseUrl(selectedConnectorConfig, details);
+            const publicHealthUrl = lingzhuPublicHealthUrl(selectedConnectorConfig, details);
+            const saveReady = publicReady && Boolean(normalizedText(publicSseUrl)) && Boolean(normalizedText(authAk));
+            const generatedAgentId = normalizedText(selectedConnectorConfig.agent_id || LINGZHU_PUBLIC_AGENT_ID) || LINGZHU_PUBLIC_AGENT_ID;
+            const logoUrl = lingzhuPlatformLogoUrl(baseUrl);
+            return [
+                {
+                    type: 'action',
+                    id: 'save-connector',
+                    label: 'Save Connector',
+                    description: saveReady
+                        ? 'Persist the generated Lingzhu values into connectors.yaml and reload the runtime.'
+                        : 'Set a public base URL and a Custom agent AK first. The Web Rokid popup applies the same save gate.',
+                    disabled: !saveReady,
+                },
+                {
+                    type: 'action',
+                    id: 'generate-lingzhu-ak',
+                    label: 'Generate AK',
+                    description: 'Create a new random Custom agent AK for the Lingzhu bridge.',
+                },
+                {
+                    type: 'action',
+                    id: 'refresh-connector',
+                    label: 'Refresh Status',
+                    description: 'Reload connector runtime snapshot and current structured config.',
+                },
+                {
+                    type: 'field',
+                    key: 'public_base_url',
+                    label: 'Public base URL',
+                    value: displayMaybeString(selectedConnectorConfig.public_base_url),
+                    description: 'Publicly reachable DeepScientist base URL used by Rokid devices.',
+                    fieldKind: 'url',
+                    editable: true,
+                },
+                {
+                    type: 'field',
+                    key: 'local_host',
+                    label: 'Local host',
+                    value: displayMaybeString(selectedConnectorConfig.local_host),
+                    description: 'Host used by DeepScientist when probing its own Lingzhu routes locally.',
+                    fieldKind: 'text',
+                    editable: true,
+                },
+                {
+                    type: 'field',
+                    key: 'gateway_port',
+                    label: 'Gateway port',
+                    value: displayMaybeString(selectedConnectorConfig.gateway_port),
+                    description: 'Port used when building the health and SSE endpoints.',
+                    fieldKind: 'text',
+                    editable: true,
+                },
+                {
+                    type: 'field',
+                    key: 'agent_id',
+                    label: 'Custom agent ID',
+                    value: displayMaybeString(selectedConnectorConfig.agent_id || LINGZHU_PUBLIC_AGENT_ID),
+                    description: 'Public agent id that must match the Rokid custom agent ID field.',
+                    fieldKind: 'text',
+                    editable: true,
+                },
+                {
+                    type: 'field',
+                    key: 'auth_ak',
+                    label: 'Custom agent AK',
+                    value: displayMaybeString(authAk),
+                    description: 'Generated token that must match the AK pasted into the Rokid custom agent form.',
+                    fieldKind: 'password',
+                    editable: true,
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-agent-id',
+                    label: 'Custom agent ID',
+                    value: displayMaybeString(generatedAgentId),
+                    description: 'Paste this exact value into the Rokid custom agent ID field.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-agent-url',
+                    label: 'Custom agent URL',
+                    value: displayMaybeString(publicSseUrl),
+                    description: 'Paste this exact value into the Rokid custom agent URL field.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-agent-ak',
+                    label: 'Custom agent AK',
+                    value: displayMaybeString(authAk),
+                    description: 'Paste this exact value into the Rokid custom agent AK field.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-agent-name',
+                    label: 'Agent name',
+                    value: LINGZHU_PLATFORM_AGENT_NAME,
+                    description: 'Suggested display name for the Rokid custom agent form.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-category',
+                    label: 'Category',
+                    value: LINGZHU_PLATFORM_CATEGORY,
+                    description: 'Recommended Rokid category for the DeepScientist agent.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-capability-summary',
+                    label: 'Capability summary',
+                    value: LINGZHU_PLATFORM_CAPABILITY_SUMMARY,
+                    description: 'Paste this capability summary into the Rokid custom agent form.',
+                    multiline: true,
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-opening-message',
+                    label: 'Opening message',
+                    value: LINGZHU_PLATFORM_OPENING_MESSAGE,
+                    description: 'Paste this greeting into the Rokid opening message field.',
+                    multiline: true,
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-input-type',
+                    label: 'Input type',
+                    value: LINGZHU_PLATFORM_INPUT_TYPE,
+                    description: 'Recommended Rokid input type for DeepScientist.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-platform-logo-url',
+                    label: 'Icon/logo URL',
+                    value: displayMaybeString(logoUrl),
+                    description: 'Optional Rokid icon URL. The Web popup shows the same DeepScientist Rokid logo.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-public-health',
+                    label: 'Public health URL',
+                    value: displayMaybeString(publicHealthUrl),
+                    description: 'Public health endpoint for debugging.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-local-sse',
+                    label: 'Local SSE URL',
+                    value: displayMaybeString(details.endpoint_url),
+                    description: 'Local SSE endpoint used by DeepScientist probes.',
+                },
+                {
+                    type: 'info',
+                    id: 'lingzhu-local-health',
+                    label: 'Local health URL',
+                    value: displayMaybeString(details.health_url),
+                    description: 'Local health endpoint used by DeepScientist probes.',
+                },
+                ...bindingActionItems,
+            ];
+        }
+        if (selectedConnectorName === 'qq') {
+            const secretValue = String(selectedConnectorConfig.app_secret ?? '').trim();
+            const qqProfileInfoItems = qqProfileSummaries.map((profile) => {
+                const statusText = profile.status === 'bound'
+                    ? 'Bound'
+                    : profile.status === 'ready'
+                        ? 'Ready for binding'
+                        : 'Waiting for first message';
+                const targetLabel = profile.selectedTarget ? connectorTargetLabel(profile.selectedTarget) || profile.selectedTarget.conversation_id : 'waiting';
+                const boundQuestId = normalizedText(profile.selectedTarget?.bound_quest_id) || 'not bound yet';
+                return {
+                    type: 'info',
+                    id: `qq-profile:${profile.profileId}`,
+                    label: `Profile · ${profile.label}`,
+                    value: [
+                        `Profile ID: ${profile.profileId}`,
+                        `App ID: ${profile.appId || '—'}`,
+                        `Detected OpenID: ${profile.mainChatId || 'waiting for first private message'}`,
+                        `Last conversation: ${profile.lastConversationId || 'waiting for runtime activity'}`,
+                        `Targets: ${profile.targetCount}`,
+                        `Preferred target: ${targetLabel}`,
+                        `Bound quest: ${boundQuestId}`,
+                        `Status: ${statusText}`,
+                    ].join('\n'),
+                    description: 'Profile-level runtime summary aligned with the Web QQ connector cards.',
+                    multiline: true,
+                };
+            });
+            return [
+                {
+                    type: 'action',
+                    id: 'save-connector',
+                    label: 'Save Connector',
+                    description: qqHasMultipleProfiles
+                        ? 'Persist shared QQ settings and reload the runtime. Use raw connectors.yaml for profile add, delete, or credential replacement.'
+                        : 'Persist the current QQ fields into connectors.yaml and reload the runtime.',
+                    disabled: false,
+                },
+                {
+                    type: 'action',
+                    id: 'refresh-connector',
+                    label: 'Refresh Status',
+                    description: 'Reload connector runtime snapshot and current structured config.',
+                },
+                {
+                    type: 'action',
+                    id: 'open-raw-connectors',
+                    label: 'Open Raw connectors.yaml',
+                    description: 'Open the full connectors config file for advanced or multi-profile QQ changes.',
+                },
+                {
+                    type: 'field',
+                    key: 'bot_name',
+                    label: 'Bot name',
+                    value: displayMaybeString(selectedConnectorConfig.bot_name),
+                    description: qqHasMultipleProfiles
+                        ? 'Default display name for QQ profiles. Add or replace per-profile bot names in raw connectors.yaml.'
+                        : 'Display name used by the QQ connector.',
+                    fieldKind: 'text',
+                    editable: !qqHasMultipleProfiles,
+                },
+                {
+                    type: 'field',
+                    key: 'app_id',
+                    label: 'App ID',
+                    value: displayMaybeString(selectedConnectorConfig.app_id),
+                    description: 'Tencent QQ bot App ID.',
+                    fieldKind: 'text',
+                    editable: !qqHasMultipleProfiles,
+                },
+                {
+                    type: 'field',
+                    key: 'app_secret',
+                    label: 'App secret',
+                    value: displayMaybeString(secretValue),
+                    description: 'QQ bot App Secret. Save this first, then send one private QQ message to the bot.',
+                    fieldKind: 'password',
+                    editable: !qqHasMultipleProfiles,
+                },
+                {
+                    type: 'field',
+                    key: 'command_prefix',
+                    label: 'Command prefix',
+                    value: displayMaybeString(selectedConnectorConfig.command_prefix),
+                    description: 'Prefix used for slash-style QQ commands.',
+                    fieldKind: 'text',
+                    editable: true,
+                },
+                {
+                    type: 'field',
+                    key: 'require_at_in_groups',
+                    label: 'Require @ mention in groups',
+                    value: displayBoolean(selectedConnectorConfig.require_at_in_groups),
+                    description: 'Only process QQ group messages when the bot is explicitly mentioned.',
+                    fieldKind: 'boolean',
+                    editable: true,
+                },
+                {
+                    type: 'field',
+                    key: 'gateway_restart_on_config_change',
+                    label: 'Restart gateway on config change',
+                    value: displayBoolean(selectedConnectorConfig.gateway_restart_on_config_change),
+                    description: 'Restart the local gateway worker after QQ settings are changed.',
+                    fieldKind: 'boolean',
+                    editable: true,
+                },
+                {
+                    type: 'field',
+                    key: 'auto_bind_dm_to_active_quest',
+                    label: 'Auto-bind DM to active quest',
+                    value: displayBoolean(selectedConnectorConfig.auto_bind_dm_to_active_quest),
+                    description: 'Allow a private QQ chat to auto-bind to the current quest.',
+                    fieldKind: 'boolean',
+                    editable: true,
+                },
+                ...qqProfileInfoItems,
+                {
+                    type: 'info',
+                    id: 'qq-detected-openid',
+                    label: 'Detected OpenID',
+                    value: displayMaybeString(selectedConnectorConfig.main_chat_id || selectedConnectorSnapshot?.main_chat_id),
+                    description: 'This value is auto-filled after the first private QQ message reaches DeepScientist.',
+                },
+                {
+                    type: 'info',
+                    id: 'qq-last-conversation',
+                    label: 'Last conversation',
+                    value: displayMaybeString(selectedConnectorSnapshot?.last_conversation_id),
+                    description: 'After the first QQ message arrives, the runtime also refreshes the latest conversation id here.',
+                },
+                {
+                    type: 'info',
+                    id: 'qq-targets',
+                    label: 'Discovered targets',
+                    value: String(selectedConnectorTargets.length || selectedConnectorSnapshot?.target_count || 0),
+                    description: 'Targets learned from QQ runtime activity. Bind the current quest to one of them below.',
+                },
+                ...bindingActionItems,
+            ];
+        }
+        return [
+            {
+                type: 'action',
+                id: 'open-raw-connectors',
+                label: 'Open Raw connectors.yaml',
+                description: 'Guided setup is not available for this connector yet. Open the raw connectors config instead.',
+            },
+            {
+                type: 'info',
+                id: 'connector-mode',
+                label: 'Mode',
+                value: displayMaybeString(selectedConnectorSnapshot?.mode || selectedConnectorConfig.transport),
+                description: 'Current connector runtime mode.',
+            },
+            ...bindingActionItems,
+        ];
+    }, [
+        baseUrl,
+        qqProfileSummaries,
+        qqHasMultipleProfiles,
+        selectedConnectorConfig,
+        selectedConnectorName,
+        selectedConnectorSnapshot,
+        selectedConnectorTargets,
+        selectedQuestForConfig?.quest_id,
+    ]);
+    const connectorDirty = useMemo(() => {
+        if (!selectedConnectorName || !connectorsDocument?.structured) {
+            return false;
+        }
+        try {
+            return (JSON.stringify(asRecord(connectorsDocument.structured[selectedConnectorName])) !==
+                JSON.stringify(asRecord(connectorsDocument.savedStructured[selectedConnectorName])));
+        }
+        catch {
+            return true;
+        }
+    }, [connectorsDocument, selectedConnectorName]);
     const slashSuggestions = useMemo(() => {
         const slashCommands = session?.acp_session?.slash_commands ?? [];
         const localCommands = [
@@ -401,8 +1174,11 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             { name: '/stop', description: 'Stop a running quest.' },
             { name: '/status', description: 'Show the current quest status.' },
             { name: '/graph', description: 'Show the quest graph.' },
-            { name: '/config', description: 'Open the local config browser.' },
-            { name: '/config connectors', description: 'Open connectors.yaml in the local config browser.' },
+            { name: '/config', description: 'Open the local config workspace.' },
+            { name: '/config connectors', description: 'Open the connector list inside config.' },
+            { name: '/config qq', description: 'Open the QQ connector setup.' },
+            { name: '/config weixin', description: 'Open the Weixin connector setup.' },
+            { name: '/config lingzhu', description: 'Open the Lingzhu connector setup.' },
         ];
         if (!input.startsWith('/')) {
             return [];
@@ -418,6 +1194,111 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             session?.acp_session?.meta?.default_reply_interaction_id;
         return snapshotTarget ? String(snapshotTarget) : null;
     }, [session]);
+    const configPanel = useMemo(() => {
+        if (!configView) {
+            return null;
+        }
+        if (configEditor?.kind === 'document') {
+            return {
+                kind: 'document-editor',
+                item: configEditor.item,
+                content: input,
+            };
+        }
+        if (configEditor?.kind === 'connector-field') {
+            return {
+                kind: 'connector-field-editor',
+                connectorName: connectorLabel(configEditor.connectorName),
+                fieldLabel: configEditor.fieldLabel,
+                content: input,
+                description: configEditor.description,
+                masked: configEditor.fieldKind === 'password',
+            };
+        }
+        if (configView === 'root') {
+            return {
+                kind: 'root',
+                items: CONFIG_ROOT_ENTRIES,
+                selectedIndex: configIndex,
+                selectedQuestId: selectedQuestForConfig?.quest_id ?? null,
+            };
+        }
+        if (configView === 'files') {
+            return {
+                kind: 'files',
+                title: configSectionTitle,
+                description: configSectionDescription,
+                items: configItems,
+                selectedIndex: configIndex,
+                selectedQuestId: selectedQuestForConfig?.quest_id ?? null,
+            };
+        }
+        if (configView === 'connector-list') {
+            return {
+                kind: 'connector-list',
+                items: connectorMenuEntries,
+                selectedIndex: configIndex,
+            };
+        }
+        if (configView === 'connector-detail' && selectedConnectorName) {
+            return {
+                kind: 'connector-detail',
+                connectorName: selectedConnectorName,
+                connectorLabel: connectorLabel(selectedConnectorName),
+                selectedIndex: configIndex,
+                items: connectorDetailItems,
+                dirty: connectorDirty,
+                snapshot: selectedConnectorSnapshot,
+                contextLine: connectorContextLine,
+                guideSections: connectorGuideSections,
+                warning: selectedConnectorName === 'qq' && qqHasMultipleProfiles
+                    ? 'QQ currently has multiple profiles. TUI supports shared settings and quest binding here, but adding, deleting, or replacing profile credentials still belongs in raw connectors.yaml.'
+                    : null,
+            };
+        }
+        if (configView === 'weixin-qr') {
+            return {
+                kind: 'weixin-qr',
+                status: weixinQrState?.status || 'waiting',
+                sessionKey: weixinQrState?.sessionKey || null,
+                qrAscii: weixinQrState?.qrAscii || null,
+                qrContent: weixinQrState?.qrContent || null,
+                qrUrl: weixinQrState?.qrUrl || null,
+                message: weixinQrState?.message || null,
+            };
+        }
+        return null;
+    }, [
+        configEditor,
+        configIndex,
+        configItems,
+        configSectionDescription,
+        configSectionTitle,
+        connectorContextLine,
+        configView,
+        connectorDetailItems,
+        connectorDirty,
+        connectorGuideSections,
+        connectorMenuEntries,
+        input,
+        qqHasMultipleProfiles,
+        selectedConnectorName,
+        selectedConnectorSnapshot,
+        selectedQuestForConfig?.quest_id,
+        weixinQrState,
+    ]);
+    const configSelectionCount = useMemo(() => {
+        if (!configPanel || configMode !== 'browse') {
+            return 0;
+        }
+        if (configPanel.kind === 'root' || configPanel.kind === 'files' || configPanel.kind === 'connector-list') {
+            return configPanel.items.length;
+        }
+        if (configPanel.kind === 'connector-detail') {
+            return configPanel.items.length;
+        }
+        return 0;
+    }, [configMode, configPanel]);
     useEffect(() => {
         activeQuestIdRef.current = activeQuestId;
     }, [activeQuestId]);
@@ -437,10 +1318,15 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             browseQuestIdRef.current = questId;
             setBrowseQuestId(questId);
         }
-        setConfigMode(null);
+        setConfigView(null);
         setConfigEditor(null);
         setConfigItems([]);
+        setConfigSectionTitle('Config');
+        setConfigSectionDescription('');
         setConfigIndex(0);
+        setConnectorsDocument(null);
+        setSelectedConnectorName(null);
+        setWeixinQrState(null);
         setQuestPanelMode(null);
         historyRef.current = [];
         pendingHistoryItemsRef.current = [];
@@ -454,10 +1340,15 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         activeQuestIdRef.current = null;
         browseQuestIdRef.current = null;
         setActiveQuestId(null);
-        setConfigMode(null);
+        setConfigView(null);
         setConfigEditor(null);
         setConfigItems([]);
+        setConfigSectionTitle('Config');
+        setConfigSectionDescription('');
         setConfigIndex(0);
+        setConnectorsDocument(null);
+        setSelectedConnectorName(null);
+        setWeixinQrState(null);
         setQuestPanelMode(null);
         setSession(null);
         historyRef.current = [];
@@ -553,8 +1444,11 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         }
     }, [baseUrl]);
     const openQuestPanel = useCallback((mode) => {
-        setConfigMode(null);
+        setConfigView(null);
         setConfigEditor(null);
+        setConnectorsDocument(null);
+        setSelectedConnectorName(null);
+        setWeixinQrState(null);
         const candidates = getPanelQuests(mode, quests);
         setQuestPanelMode(mode);
         if (candidates.length === 0) {
@@ -581,15 +1475,60 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
                     : 'Resume quest · use arrows and Enter to resume.');
     }, [activeQuestId, browseQuestId, quests]);
     const closeConfigScreen = useCallback((nextStatus) => {
-        setConfigMode(null);
+        setConfigView(null);
         setConfigEditor(null);
         setConfigItems([]);
+        setConfigSectionTitle('Config');
+        setConfigSectionDescription('');
         setConfigIndex(0);
+        setConnectorsDocument(null);
+        setSelectedConnectorName(null);
+        setWeixinQrState(null);
         setInput('');
         if (nextStatus) {
             setStatusLine(nextStatus);
         }
     }, []);
+    const loadConnectorsDocument = useCallback(async () => {
+        const payload = await client.configDocument(baseUrl, 'connectors');
+        const structured = asRecord(payload.meta?.structured_config);
+        return {
+            item: {
+                id: 'global:connectors',
+                scope: 'global',
+                name: 'connectors',
+                title: payload.title || 'connectors.yaml',
+                path: payload.path,
+                writable: true,
+                configName: 'connectors',
+            },
+            revision: payload.revision,
+            savedStructured: cloneStructured(structured),
+            structured: cloneStructured(structured),
+        };
+    }, [baseUrl]);
+    const setWeixinQrPayload = useCallback(async (payload) => {
+        const qrContent = String(payload.qrcode_content || '').trim();
+        const qrUrl = String(payload.qrcode_url || '').trim();
+        let qrAscii = '';
+        const renderable = qrContent || qrUrl;
+        if (renderable && !looksLikeWeixinQrImageUrl(qrUrl || qrContent)) {
+            try {
+                qrAscii = await renderQrAscii(qrContent || qrUrl);
+            }
+            catch {
+                qrAscii = '';
+            }
+        }
+        setWeixinQrState({
+            sessionKey: String(payload.session_key || '').trim(),
+            status: String(payload.status || 'wait').trim() || 'wait',
+            qrContent: qrContent || undefined,
+            qrUrl: qrUrl || undefined,
+            qrAscii: qrAscii || undefined,
+            message: String(payload.message || '').trim() || undefined,
+        });
+    }, []);
     const openConfigEditor = useCallback(async (item) => {
         try {
             let payload;
@@ -605,8 +1544,9 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
                 payload = await client.openDocument(baseUrl, questId, item.documentId);
             }
             setQuestPanelMode(null);
-            setConfigMode('edit');
+            setConfigView('files');
             setConfigEditor({
+                kind: 'document',
                 item,
                 revision: payload.revision,
                 content: payload.content,
@@ -618,19 +1558,22 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             setStatusLine(error instanceof Error ? error.message : String(error));
         }
     }, [baseUrl, selectedQuestForConfig]);
-    const openConfigBrowser = useCallback(async (target) => {
+    const openConfigFiles = useCallback(async (scope, target) => {
         try {
-            const globalEntries = await client.configFiles(baseUrl);
-            const globalItems = buildGlobalConfigItems(globalEntries);
-            const questItems = buildQuestConfigItems(selectedQuestForConfig?.quest_id ?? null, selectedQuestForConfig?.quest_root);
-            const nextItems = [...globalItems, ...questItems];
+            const nextItems = scope === 'global'
+                ? buildGlobalConfigItems(await client.configFiles(baseUrl))
+                : buildQuestConfigItems(selectedQuestForConfig?.quest_id ?? null, selectedQuestForConfig?.quest_root);
             setQuestPanelMode(null);
+            setConfigView('files');
             setConfigItems(nextItems);
+            setConfigSectionTitle(scope === 'global' ? 'Global Config Files' : 'Current Quest Files');
+            setConfigSectionDescription(scope === 'global'
+                ? 'Choose a global config file and press Enter to edit it.'
+                : 'Choose a quest-local config file and press Enter to edit it.');
             setConfigEditor(null);
-            setConfigMode('browse');
             if (nextItems.length === 0) {
                 setConfigIndex(0);
-                setStatusLine('No config files available.');
+                setStatusLine(scope === 'global' ? 'No global config files available.' : 'No current quest config files available.');
                 return;
             }
             if (target) {
@@ -642,17 +1585,177 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
                 }
             }
             setConfigIndex(0);
-            setStatusLine('Config browser · global and current quest config files.');
+            setStatusLine(scope === 'global' ? 'Global config files.' : 'Current quest config files.');
         }
         catch (error) {
             setStatusLine(error instanceof Error ? error.message : String(error));
         }
     }, [baseUrl, openConfigEditor, selectedQuestForConfig]);
+    const openConfigRoot = useCallback((nextStatus = 'Config · choose a section with arrows and Enter.') => {
+        setQuestPanelMode(null);
+        setConfigView('root');
+        setConfigEditor(null);
+        setConfigItems([]);
+        setConfigSectionTitle('Config');
+        setConfigSectionDescription('');
+        setConfigIndex(0);
+        setSelectedConnectorName(null);
+        setWeixinQrState(null);
+        setInput('');
+        setStatusLine(nextStatus);
+    }, []);
+    const openConfigBrowser = useCallback((nextStatus) => {
+        openConfigRoot(nextStatus);
+    }, [openConfigRoot]);
+    const openConnectorBrowser = useCallback(async (targetConnector) => {
+        try {
+            const document = await loadConnectorsDocument();
+            const names = connectorNamesFromStructuredConfig(document.structured);
+            const browseNames = names.length > 0 ? names : CONNECTOR_ORDER;
+            setQuestPanelMode(null);
+            setConfigView('connector-list');
+            setConfigEditor(null);
+            setConnectorsDocument(document);
+            setSelectedConnectorName(null);
+            setWeixinQrState(null);
+            setInput('');
+            if (targetConnector) {
+                const directIndex = browseNames.findIndex((item) => item === targetConnector);
+                setConfigIndex(directIndex >= 0 ? directIndex : 0);
+                return;
+            }
+            setConfigIndex(0);
+            setStatusLine('Connectors · choose a connector with arrows and Enter.');
+        }
+        catch (error) {
+            setStatusLine(error instanceof Error ? error.message : String(error));
+        }
+    }, [loadConnectorsDocument]);
+    const updateConnectorDraft = useCallback((connectorName, patch) => {
+        setConnectorsDocument((current) => {
+            if (!current) {
+                return current;
+            }
+            const nextStructured = cloneStructured(current.structured);
+            const currentConnector = asRecord(nextStructured[connectorName]);
+            nextStructured[connectorName] = {
+                ...currentConnector,
+                ...patch,
+            };
+            return {
+                ...current,
+                structured: nextStructured,
+            };
+        });
+    }, []);
+    const openConnectorDetail = useCallback(async (connectorName) => {
+        try {
+            let currentDocument = connectorsDocument ?? (await loadConnectorsDocument());
+            if (connectorName === 'lingzhu') {
+                const currentLingzhu = asRecord(currentDocument.structured.lingzhu);
+                const patch = {};
+                if (!resolveLingzhuAuthAk(currentLingzhu.auth_ak)) {
+                    patch.auth_ak = createLingzhuAk();
+                }
+                if (!String(currentLingzhu.agent_id || '').trim()) {
+                    patch.agent_id = LINGZHU_PUBLIC_AGENT_ID;
+                }
+                if (!String(currentLingzhu.local_host || '').trim()) {
+                    patch.local_host = '127.0.0.1';
+                }
+                if (!String(currentLingzhu.gateway_port || '').trim()) {
+                    try {
+                        patch.gateway_port = String(new URL(baseUrl).port || '20999');
+                    }
+                    catch {
+                        patch.gateway_port = '20999';
+                    }
+                }
+                if (!String(currentLingzhu.public_base_url || '').trim()) {
+                    try {
+                        const currentBaseUrl = new URL(baseUrl);
+                        if (currentBaseUrl.hostname === '0.0.0.0') {
+                            currentBaseUrl.hostname = '127.0.0.1';
+                        }
+                        const resolvedBaseUrl = currentBaseUrl.toString().replace(/\/$/, '');
+                        if (looksLikePublicBaseUrl(resolvedBaseUrl)) {
+                            patch.public_base_url = resolvedBaseUrl;
+                        }
+                    }
+                    catch {
+                        // ignore parse failures
+                    }
+                }
+                if (Object.keys(patch).length > 0) {
+                    currentDocument = {
+                        ...currentDocument,
+                        structured: {
+                            ...cloneStructured(currentDocument.structured),
+                            lingzhu: {
+                                ...currentLingzhu,
+                                ...patch,
+                            },
+                        },
+                    };
+                }
+            }
+            setConnectorsDocument(currentDocument);
+            setSelectedConnectorName(connectorName);
+            setConfigView('connector-detail');
+            setConfigEditor(null);
+            setWeixinQrState(null);
+            setConfigIndex(0);
+            setInput('');
+            setStatusLine(`${connectorLabel(connectorName)} connector · arrows to navigate, Enter to edit or run an action.`);
+        }
+        catch (error) {
+            setStatusLine(error instanceof Error ? error.message : String(error));
+        }
+    }, [baseUrl, connectorsDocument, loadConnectorsDocument]);
+    const openRawConnectorsEditor = useCallback(async () => {
+        const document = connectorsDocument ?? (await loadConnectorsDocument());
+        setConnectorsDocument(document);
+        await openConfigEditor(document.item);
+    }, [connectorsDocument, loadConnectorsDocument, openConfigEditor]);
+    const saveConnectorDraft = useCallback(async () => {
+        if (!connectorsDocument) {
+            return;
+        }
+        try {
+            const structuredToSave = (() => {
+                if (!selectedConnectorName) {
+                    return connectorsDocument.structured;
+                }
+                const merged = cloneStructured(connectorsDocument.savedStructured);
+                merged[selectedConnectorName] = cloneStructured(asRecord(connectorsDocument.structured[selectedConnectorName]));
+                return merged;
+            })();
+            const payload = await client.saveStructuredConfig(baseUrl, 'connectors', structuredToSave, connectorsDocument.revision);
+            if (!payload.ok) {
+                setStatusLine(payload.message || payload.errors?.[0] || 'Connector save failed.');
+                return;
+            }
+            const refreshedDocument = await loadConnectorsDocument();
+            setConnectorsDocument(refreshedDocument);
+            await refresh(true, activeQuestIdRef.current);
+            setStatusLine(`Saved ${selectedConnectorName ? connectorLabel(selectedConnectorName) : 'connectors'} settings.`);
+        }
+        catch (error) {
+            setStatusLine(error instanceof Error ? error.message : String(error));
+        }
+    }, [baseUrl, connectorsDocument, loadConnectorsDocument, refresh, selectedConnectorName]);
     const saveConfigEditor = useCallback(async (content) => {
         if (!configEditor) {
             return;
         }
         try {
+            if (configEditor.kind === 'connector-field') {
+                updateConnectorDraft(configEditor.connectorName, { [configEditor.fieldKey]: content });
+                setInput('');
+                setConfigEditor(null);
+                setStatusLine(`Updated ${configEditor.fieldLabel} in draft. Save the connector to persist it.`);
+                return;
+            }
             if (configEditor.item.scope === 'global' && configEditor.item.configName) {
                 const payload = await client.saveConfig(baseUrl, configEditor.item.configName, content, configEditor.revision);
                 if (payload.ok === false) {
@@ -674,14 +1777,199 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             }
             setInput('');
             setConfigEditor(null);
-            setConfigMode('browse');
+            setConfigView('files');
             setStatusLine(`Saved ${configEditor.item.title}`);
             await refresh(true, activeQuestId);
         }
         catch (error) {
             setStatusLine(error instanceof Error ? error.message : String(error));
         }
-    }, [activeQuestId, baseUrl, configEditor, refresh, selectedQuestForConfig]);
+    }, [activeQuestId, baseUrl, configEditor, refresh, selectedQuestForConfig, updateConnectorDraft]);
+    const openConnectorFieldEditor = useCallback((fieldKey, fieldLabel, description, fieldKind) => {
+        if (!selectedConnectorName) {
+            return;
+        }
+        const currentValue = String(selectedConnectorConfig[fieldKey] ?? '').trim();
+        setConfigEditor({
+            kind: 'connector-field',
+            connectorName: selectedConnectorName,
+            fieldKey,
+            fieldLabel,
+            description,
+            fieldKind,
+            content: currentValue,
+        });
+        setInput(currentValue);
+        setStatusLine(`Editing ${fieldLabel} · Enter apply · Esc cancel`);
+    }, [selectedConnectorConfig, selectedConnectorName]);
+    const toggleConnectorBooleanField = useCallback((fieldKey, fieldLabel) => {
+        if (!selectedConnectorName) {
+            return;
+        }
+        const currentValue = Boolean(selectedConnectorConfig[fieldKey]);
+        updateConnectorDraft(selectedConnectorName, { [fieldKey]: !currentValue });
+        setStatusLine(`Updated ${fieldLabel} in draft. Save the connector to persist it.`);
+    }, [selectedConnectorConfig, selectedConnectorName, updateConnectorDraft]);
+    const handleConnectorAction = useCallback(async (actionId) => {
+        if (!selectedConnectorName) {
+            return;
+        }
+        const bindTarget = parseConnectorBindActionId(actionId);
+        if (bindTarget) {
+            const questId = selectedQuestForConfig?.quest_id;
+            if (!questId) {
+                setStatusLine('Open a quest first, then bind the connector target to that quest.');
+                return;
+            }
+            await client.updateQuestBindings(baseUrl, questId, {
+                connector: bindTarget.connectorName,
+                conversation_id: bindTarget.conversationId,
+                force: true,
+            });
+            await refresh(true, questId);
+            setStatusLine(`Bound ${connectorLabel(bindTarget.connectorName)} target to ${questId}.`);
+            return;
+        }
+        const unbindConnectorName = parseConnectorUnbindActionId(actionId);
+        if (unbindConnectorName) {
+            const questId = selectedQuestForConfig?.quest_id;
+            if (!questId) {
+                setStatusLine('Open a quest first, then remove the connector binding from that quest.');
+                return;
+            }
+            await client.updateQuestBindings(baseUrl, questId, {
+                connector: unbindConnectorName,
+                conversation_id: null,
+                force: true,
+            });
+            await refresh(true, questId);
+            setStatusLine(`Unbound ${connectorLabel(unbindConnectorName)} from ${questId}.`);
+            return;
+        }
+        if (actionId === 'save-connector') {
+            await saveConnectorDraft();
+            return;
+        }
+        if (actionId === 'refresh-connector') {
+            if (selectedConnectorName === 'weixin' || selectedConnectorName === 'qq' || selectedConnectorName === 'lingzhu') {
+                const document = await loadConnectorsDocument();
+                setConnectorsDocument(document);
+            }
+            await refresh(true, activeQuestIdRef.current);
+            setStatusLine(`${connectorLabel(selectedConnectorName)} connector refreshed.`);
+            return;
+        }
+        if (actionId === 'generate-lingzhu-ak') {
+            updateConnectorDraft('lingzhu', { auth_ak: createLingzhuAk() });
+            setStatusLine('Generated a new Lingzhu Custom agent AK in draft.');
+            return;
+        }
+        if (actionId === 'weixin-start-login') {
+            const payload = await client.startWeixinQrLogin(baseUrl, Boolean(selectedConnectorSnapshot?.enabled));
+            if (!payload.ok || !payload.session_key) {
+                setStatusLine(payload.message || 'Failed to start Weixin QR login.');
+                return;
+            }
+            setConfigView('weixin-qr');
+            setConfigIndex(0);
+            await setWeixinQrPayload({
+                session_key: payload.session_key,
+                status: 'wait',
+                qrcode_content: payload.qrcode_content,
+                qrcode_url: payload.qrcode_url,
+                message: payload.message,
+            });
+            setStatusLine('Weixin QR login started. Scan the QR code with WeChat.');
+            return;
+        }
+        if (actionId === 'open-raw-connectors') {
+            await openRawConnectorsEditor();
+        }
+    }, [
+        baseUrl,
+        loadConnectorsDocument,
+        openRawConnectorsEditor,
+        refresh,
+        saveConnectorDraft,
+        selectedConnectorName,
+        selectedConnectorSnapshot?.enabled,
+        selectedQuestForConfig?.quest_id,
+        setWeixinQrPayload,
+        updateConnectorDraft,
+    ]);
+    const handleConfigBrowseSelection = useCallback(async () => {
+        if (!configPanel) {
+            return;
+        }
+        if (configPanel.kind === 'root') {
+            const selected = configPanel.items[configIndex];
+            if (!selected) {
+                return;
+            }
+            if (selected.id === 'connectors') {
+                await openConnectorBrowser();
+                return;
+            }
+            if (selected.id === 'global-files') {
+                await openConfigFiles('global');
+                return;
+            }
+            if (selected.id === 'quest-files') {
+                await openConfigFiles('quest');
+            }
+            return;
+        }
+        if (configPanel.kind === 'files') {
+            const selected = configPanel.items[configIndex] ?? null;
+            if (!selected) {
+                setStatusLine('No config file selected.');
+                return;
+            }
+            await openConfigEditor(selected);
+            return;
+        }
+        if (configPanel.kind === 'connector-list') {
+            const selected = configPanel.items[configIndex] ?? null;
+            if (!selected) {
+                setStatusLine('No connector selected.');
+                return;
+            }
+            await openConnectorDetail(selected.name);
+            return;
+        }
+        if (configPanel.kind === 'connector-detail') {
+            const selected = configPanel.items[configIndex] ?? null;
+            if (!selected) {
+                return;
+            }
+            if (selected.type === 'action') {
+                if (!selected.disabled) {
+                    await handleConnectorAction(selected.id);
+                }
+                return;
+            }
+            if (selected.type === 'field') {
+                if (!selected.editable) {
+                    return;
+                }
+                if (selected.fieldKind === 'boolean') {
+                    toggleConnectorBooleanField(selected.key, selected.label);
+                    return;
+                }
+                openConnectorFieldEditor(selected.key, selected.label, selected.description, selected.fieldKind);
+            }
+        }
+    }, [
+        configIndex,
+        configPanel,
+        handleConnectorAction,
+        openConfigEditor,
+        openConfigFiles,
+        openConnectorBrowser,
+        openConnectorDetail,
+        openConnectorFieldEditor,
+        toggleConnectorBooleanField,
+    ]);
     const closeQuestPanel = useCallback((nextStatus) => {
         setQuestPanelMode(null);
         if (nextStatus) {
@@ -713,10 +2001,10 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
     }, [baseUrl, closeQuestPanel, focusQuest, panelQuests, questPanelIndex, questPanelMode]);
     const cycleQuest = useCallback((direction) => {
         if (configMode === 'browse') {
-            if (configItems.length === 0) {
+            if (configSelectionCount === 0) {
                 return;
             }
-            setConfigIndex((previous) => (previous + direction + configItems.length) % configItems.length);
+            setConfigIndex((previous) => (previous + direction + configSelectionCount) % configSelectionCount);
             return;
         }
         if (questPanelMode) {
@@ -744,7 +2032,7 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         const nextIndex = index < 0 ? 0 : (index + direction + quests.length) % quests.length;
         const nextQuestId = quests[nextIndex]?.quest_id ?? null;
         setBrowseQuestId(nextQuestId);
-    }, [activeQuestId, browseQuestId, configItems.length, configMode, panelQuests, questPanelMode, quests]);
+    }, [activeQuestId, browseQuestId, configMode, configSelectionCount, panelQuests, questPanelMode, quests]);
     useEffect(() => {
         void refresh(true, initialQuestId);
     }, [initialQuestId, refresh]);
@@ -852,6 +2140,63 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             }
         };
     }, [activeQuestId, baseUrl, refresh]);
+    useEffect(() => {
+        if (configView !== 'weixin-qr' || !weixinQrState?.sessionKey) {
+            return;
+        }
+        let cancelled = false;
+        let timer = null;
+        const poll = async () => {
+            try {
+                const payload = await client.waitWeixinQrLogin(baseUrl, weixinQrState.sessionKey, 1500);
+                if (cancelled) {
+                    return;
+                }
+                await setWeixinQrPayload({
+                    session_key: payload.session_key || weixinQrState.sessionKey,
+                    status: payload.status,
+                    qrcode_content: payload.qrcode_content,
+                    qrcode_url: payload.qrcode_url,
+                    message: payload.message,
+                });
+                if (payload.connected) {
+                    const document = await loadConnectorsDocument();
+                    if (cancelled) {
+                        return;
+                    }
+                    setConnectorsDocument(document);
+                    await refresh(true, activeQuestIdRef.current);
+                    if (cancelled) {
+                        return;
+                    }
+                    setSelectedConnectorName('weixin');
+                    setConfigView('connector-detail');
+                    setConfigIndex(0);
+                    setStatusLine(payload.message || 'Weixin login succeeded and the connector config was saved.');
+                    return;
+                }
+            }
+            catch (error) {
+                if (!cancelled) {
+                    setStatusLine(error instanceof Error ? error.message : String(error));
+                }
+            }
+            if (!cancelled) {
+                timer = setTimeout(() => {
+                    void poll();
+                }, 1200);
+            }
+        };
+        timer = setTimeout(() => {
+            void poll();
+        }, 400);
+        return () => {
+            cancelled = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+        };
+    }, [baseUrl, configView, loadConnectorsDocument, refresh, setWeixinQrPayload, weixinQrState?.sessionKey]);
     const submit = useCallback(async (override) => {
         const rawText = override ?? input;
         if (configMode === 'edit' && configEditor) {
@@ -860,12 +2205,7 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         }
         const text = rawText.trim();
         if (configMode === 'browse' && !text) {
-            const selected = configItems[configIndex] ?? null;
-            if (!selected) {
-                setStatusLine('No config file selected.');
-                return;
-            }
-            await openConfigEditor(selected);
+            await handleConfigBrowseSelection();
             return;
         }
         if (configMode === 'browse' && !text.startsWith('/')) {
@@ -941,11 +2281,13 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
                 return;
             }
             if (slash?.name === '/resume') {
-                if (!slash.arg) {
+                const target = slash.arg
+                    ? resolveQuestToken(slash.arg, quests)
+                    : quests.find((quest) => quest.quest_id === (activeQuestId || browseQuestId)) ?? null;
+                if (!slash.arg && !target) {
                     openQuestPanel('resume');
                     return;
                 }
-                const target = resolveQuestToken(slash.arg, quests);
                 if (!target) {
                     setStatusLine(`Unknown quest · ${slash.arg}`);
                     return;
@@ -969,7 +2311,43 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
                 return;
             }
             if (slash?.name === '/config') {
-                await openConfigBrowser(slash.arg || undefined);
+                const arg = String(slash.arg || '').trim();
+                if (!arg) {
+                    openConfigRoot();
+                    return;
+                }
+                const tokens = arg.split(/\s+/).filter(Boolean);
+                const first = tokens[0]?.toLowerCase() || '';
+                const second = tokens[1]?.toLowerCase() || '';
+                const directConnector = resolveManagedConnectorName(first);
+                const nestedConnector = first === 'connectors' ? resolveManagedConnectorName(second) : null;
+                if (first === 'connectors' && nestedConnector) {
+                    await openConnectorBrowser(nestedConnector);
+                    await openConnectorDetail(nestedConnector);
+                    return;
+                }
+                if (directConnector) {
+                    await openConnectorBrowser(directConnector);
+                    await openConnectorDetail(directConnector);
+                    return;
+                }
+                if (first === 'connectors') {
+                    await openConnectorBrowser();
+                    return;
+                }
+                if (first === 'global') {
+                    await openConfigFiles('global');
+                    return;
+                }
+                if (first === 'quest') {
+                    await openConfigFiles('quest');
+                    return;
+                }
+                if (first === 'connectors.yaml') {
+                    await openConfigFiles('global', 'connectors');
+                    return;
+                }
+                await openConfigFiles('global', arg);
                 return;
             }
             if (slash?.name === '/new') {
@@ -1105,15 +2483,17 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         browseQuestId,
         configEditor,
         configIndex,
-        configItems,
         configMode,
         closeQuestPanel,
         focusQuest,
+        handleConfigBrowseSelection,
         handleQuestPanelSelection,
         input,
         leaveQuest,
-        openConfigBrowser,
-        openConfigEditor,
+        openConfigFiles,
+        openConfigRoot,
+        openConnectorBrowser,
+        openConnectorDetail,
         openQuestPanel,
         questPanelMode,
         quests,
@@ -1121,6 +2501,32 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         replyTargetId,
         saveConfigEditor,
     ]);
+    const backFromConfigBrowse = useCallback(() => {
+        if (!configView) {
+            return;
+        }
+        if (configView === 'root') {
+            closeConfigScreen('Config browser closed.');
+            return;
+        }
+        if (configView === 'files' || configView === 'connector-list') {
+            openConfigRoot();
+            return;
+        }
+        if (configView === 'connector-detail') {
+            setConfigView('connector-list');
+            setConfigIndex(0);
+            setSelectedConnectorName(null);
+            setWeixinQrState(null);
+            setStatusLine('Connectors · choose a connector with arrows and Enter.');
+            return;
+        }
+        if (configView === 'weixin-qr') {
+            setConfigView('connector-detail');
+            setConfigIndex(0);
+            setStatusLine('Back to Weixin connector details.');
+        }
+    }, [closeConfigScreen, configView, openConfigRoot]);
     useInput((value, key) => {
         const canBrowseSelection = configMode === 'browse' || Boolean(questPanelMode);
         const canBrowseHomeQuests = !activeQuestId && input.length === 0;
@@ -1138,7 +2544,7 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             return;
         }
         if (key.ctrl && value.toLowerCase() === 'g') {
-            void openConfigBrowser();
+            openConfigRoot();
             return;
         }
         if (key.ctrl && value.toLowerCase() === 'b') {
@@ -1152,14 +2558,13 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         }
         if (key.escape) {
             if (configMode === 'edit') {
-                setConfigMode('browse');
                 setConfigEditor(null);
                 setInput('');
                 setStatusLine('Config edit cancelled.');
                 return;
             }
             if (configMode === 'browse') {
-                closeConfigScreen('Config browser closed.');
+                backFromConfigBrowse();
                 return;
             }
             if (questPanelMode) {
@@ -1171,10 +2576,7 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         }
         if (submitRequested) {
             if (configMode === 'browse' && input.trim().length === 0) {
-                const selected = configItems[configIndex] ?? null;
-                if (selected) {
-                    void openConfigEditor(selected);
-                }
+                void handleConfigBrowseSelection();
                 return;
             }
         }
@@ -1187,12 +2589,7 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             return;
         }
     });
-    return (React.createElement(DefaultAppLayout, { baseUrl: baseUrl, quests: quests, activeQuestId: activeQuestId, browseQuestId: browseQuestId, configMode: configMode, configItems: configItems, configIndex: configIndex, configEditor: configEditor
-            ? {
-                item: configEditor.item,
-                content: input,
-            }
-            : null, snapshot: activeQuest, session: session, connectors: connectors, history: history, pendingHistoryItems: pendingHistoryItems, input: input, connectionState: connectionState, statusLine: statusLine, suggestions: slashSuggestions, questPanelMode: questPanelMode, questPanelQuests: panelQuests, questPanelIndex: questPanelIndex, onQuestPanelMove: (direction) => {
+    return (React.createElement(DefaultAppLayout, { baseUrl: baseUrl, quests: quests, activeQuestId: activeQuestId, browseQuestId: browseQuestId, configMode: configMode, configPanel: configPanel, snapshot: activeQuest, session: session, connectors: connectors, history: history, pendingHistoryItems: pendingHistoryItems, input: input, connectionState: connectionState, statusLine: statusLine, suggestions: slashSuggestions, questPanelMode: questPanelMode, questPanelQuests: panelQuests, questPanelIndex: questPanelIndex, onQuestPanelMove: (direction) => {
             cycleQuest(direction);
         }, onQuestPanelConfirm: () => {
             void handleQuestPanelSelection();
@@ -1201,10 +2598,7 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
         }, onChange: setInput, onSubmit: (override) => {
             const submitted = override ?? input;
             if (configMode === 'browse' && !String(submitted).trim()) {
-                const selected = configItems[configIndex] ?? null;
-                if (selected) {
-                    void openConfigEditor(selected);
-                }
+                void handleConfigBrowseSelection();
                 return;
             }
             if (questPanelMode && !String(submitted).trim()) {
@@ -1218,14 +2612,13 @@ export const AppContainer = ({ baseUrl, initialQuestId = null, }) => {
             void submit(override);
         }, onCancel: () => {
             if (configMode === 'edit') {
-                setConfigMode('browse');
                 setConfigEditor(null);
                 setInput('');
                 setStatusLine('Config edit cancelled.');
                 return;
             }
             if (configMode === 'browse') {
-                closeConfigScreen('Config browser closed.');
+                backFromConfigBrowse();
                 return;
             }
             if (questPanelMode) {