@hzttt/config-portal 2026.2.8

package/README.md

@@ -0,0 +1,19 @@
+# OpenClaw Config Portal Plugin
+
+Visual config plugin for:
+
+- Kimi Coding K2.5 model settings
+- Qwen model settings
+- Default model switching (Kimi/Qwen)
+- Feishu channel settings
+
+## Routes
+
+- Page: `/plugins/openclaw-config-portal`
+- API: `/plugins/openclaw-config-portal/api/config`
+
+## Notes
+
+- Saving config writes to OpenClaw config file directly.
+- Restart Gateway after saving so runtime model/channel changes take effect.
+

package/index.ts

@@ -0,0 +1,168 @@
+import { readFileSync } from "node:fs";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { applyPortalPayload, buildPortalSnapshot } from "./src/config-state.js";
+
+const PORTAL_PATH = "/plugins/openclaw-config-portal";
+const PORTAL_PATH_WITH_SLASH = `${PORTAL_PATH}/`;
+const PORTAL_API_PATH = `${PORTAL_PATH}/api/config`;
+const PORTAL_API_PATH_WITH_SLASH = `${PORTAL_API_PATH}/`;
+const MAX_BODY_BYTES = 1024 * 1024;
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.setHeader("Cache-Control", "no-cache");
+  res.end(JSON.stringify(body));
+}
+
+function sendText(res: ServerResponse, status: number, text: string): void {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "text/plain; charset=utf-8");
+  res.setHeader("Cache-Control", "no-cache");
+  res.end(text);
+}
+
+function sendMethodNotAllowed(res: ServerResponse, allow: string): void {
+  res.statusCode = 405;
+  res.setHeader("Allow", allow);
+  sendText(res, 405, "Method Not Allowed");
+}
+
+async function readJsonBody(req: IncomingMessage): Promise<{ ok: true; value: unknown } | { ok: false; error: string }> {
+  return new Promise((resolve) => {
+    const chunks: Buffer[] = [];
+    let size = 0;
+
+    req.on("data", (chunk: Buffer) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        resolve({ ok: false, error: "Request body too large." });
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+
+    req.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf8").trim();
+        if (!raw) {
+          resolve({ ok: false, error: "Request body is empty." });
+          return;
+        }
+        resolve({ ok: true, value: JSON.parse(raw) });
+      } catch {
+        resolve({ ok: false, error: "Invalid JSON payload." });
+      }
+    });
+
+    req.on("error", () => {
+      resolve({ ok: false, error: "Failed to read request body." });
+    });
+  });
+}
+
+function buildPageHandler(html: string) {
+  return (_req: IncomingMessage, res: ServerResponse) => {
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.setHeader("Cache-Control", "no-cache");
+    res.end(html);
+  };
+}
+
+async function handleConfigRead(api: OpenClawPluginApi, res: ServerResponse) {
+  const cfg = api.runtime.config.loadConfig();
+  sendJson(res, 200, {
+    ok: true,
+    config: buildPortalSnapshot(cfg),
+    routes: {
+      page: PORTAL_PATH,
+      api: PORTAL_API_PATH,
+    },
+  });
+}
+
+async function handleConfigWrite(api: OpenClawPluginApi, req: IncomingMessage, res: ServerResponse) {
+  const body = await readJsonBody(req);
+  if (!body.ok) {
+    sendJson(res, 400, { ok: false, error: body.error });
+    return;
+  }
+
+  try {
+    const current = api.runtime.config.loadConfig();
+    const next = applyPortalPayload(current, body.value);
+    await api.runtime.config.writeConfigFile(next);
+    const refreshed = api.runtime.config.loadConfig();
+
+    sendJson(res, 200, {
+      ok: true,
+      config: buildPortalSnapshot(refreshed),
+      message: "Config saved. Restart gateway to apply model/channel runtime changes.",
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    sendJson(res, 400, {
+      ok: false,
+      error: message,
+    });
+  }
+}
+
+const plugin = {
+  id: "openclaw-config-portal",
+  name: "OpenClaw Config Portal",
+  description: "Visual config page for Kimi/Qwen model switch and Feishu channel settings",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenClawPluginApi) {
+    const htmlPath = api.resolvePath("./web/index.html");
+    const html = readFileSync(htmlPath, "utf8");
+    const servePage = buildPageHandler(html);
+
+    const pageHandler = (req: IncomingMessage, res: ServerResponse) => {
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        sendMethodNotAllowed(res, "GET, HEAD");
+        return;
+      }
+      if (req.method === "HEAD") {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.setHeader("Cache-Control", "no-cache");
+        res.end();
+        return;
+      }
+      servePage(req, res);
+    };
+
+    const apiHandler = async (req: IncomingMessage, res: ServerResponse) => {
+      if (req.method === "GET") {
+        await handleConfigRead(api, res);
+        return;
+      }
+      if (req.method === "POST") {
+        await handleConfigWrite(api, req, res);
+        return;
+      }
+      sendMethodNotAllowed(res, "GET, POST");
+    };
+
+    api.registerHttpRoute({ path: PORTAL_PATH, handler: pageHandler });
+    api.registerHttpRoute({ path: PORTAL_PATH_WITH_SLASH, handler: pageHandler });
+    api.registerHttpRoute({ path: PORTAL_API_PATH, handler: apiHandler });
+    api.registerHttpRoute({ path: PORTAL_API_PATH_WITH_SLASH, handler: apiHandler });
+
+    api.registerCommand({
+      name: "config-portal",
+      description: "Show the visual config portal URL.",
+      requireAuth: false,
+      handler: () => ({
+        text: `Open this URL in your browser: ${PORTAL_PATH}`,
+      }),
+    });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "openclaw-config-portal",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}
+

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@hzttt/config-portal",
+  "version": "2026.2.8",
+  "description": "OpenClaw visual config portal plugin (Kimi/Qwen/Feishu)",
+  "type": "module",
+  "devDependencies": {
+    "openclaw": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/src/config-state.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, test } from "vitest";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { applyPortalPayload, buildPortalSnapshot } from "./config-state.js";
+
+describe("openclaw-config-portal config state", () => {
+  test("buildPortalSnapshot returns defaults for empty config", () => {
+    const snapshot = buildPortalSnapshot({} as OpenClawConfig);
+
+    expect(snapshot.activeModelProvider).toBe("kimi");
+    expect(snapshot.kimi.providerId).toBe("kimi-coding");
+    expect(snapshot.qwen.providerId).toBe("qwen");
+    expect(snapshot.feishu.webhookPath).toBe("/feishu/events");
+  });
+
+  test("applyPortalPayload writes providers and switches default model", () => {
+    const baseConfig = {
+      agents: {
+        defaults: {
+          model: {
+            primary: "openai/gpt-5",
+            fallbacks: ["openai/gpt-4.1"],
+          },
+          models: {
+            "openai/gpt-5": { alias: "openai" },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    const next = applyPortalPayload(baseConfig, {
+      activeModelProvider: "qwen",
+      kimi: {
+        providerId: "kimi-coding",
+        modelId: "kimi-k2.5-coding-preview",
+        baseUrl: "api.moonshot.cn",
+        apiKey: "kimi-secret",
+        alias: "kimi",
+      },
+      qwen: {
+        providerId: "qwen",
+        modelId: "qwen-plus",
+        baseUrl: "https://dashscope.aliyuncs.com/compatible-mode",
+        apiKey: "qwen-secret",
+        alias: "qwen",
+      },
+      feishu: {
+        enabled: true,
+        appId: "app-id",
+        appSecret: "app-secret",
+        encryptKey: "encrypt-key",
+        verificationToken: "verify-token",
+        domainMode: "feishu",
+        customDomain: "",
+        connectionMode: "webhook",
+        webhookPath: "/feishu/custom",
+        dmPolicy: "pairing",
+        allowFrom: ["user-1"],
+        groupPolicy: "allowlist",
+        groupAllowFrom: ["group-1"],
+        requireMention: true,
+      },
+    });
+
+    expect(next.models?.providers?.["kimi-coding"]?.baseUrl).toBe("https://api.moonshot.cn/v1");
+    expect(next.models?.providers?.qwen?.baseUrl).toBe(
+      "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    );
+    expect(next.agents?.defaults?.model?.primary).toBe("qwen/qwen-plus");
+    expect(next.agents?.defaults?.model?.fallbacks).toEqual(["openai/gpt-4.1"]);
+    expect(next.channels?.feishu && (next.channels.feishu as { enabled?: boolean }).enabled).toBe(
+      true,
+    );
+  });
+
+  test("applyPortalPayload auto-adds wildcard for feishu dmPolicy=open", () => {
+    const next = applyPortalPayload({} as OpenClawConfig, {
+      activeModelProvider: "kimi",
+      kimi: {
+        providerId: "kimi-coding",
+        modelId: "kimi-k2.5-coding-preview",
+        baseUrl: "https://api.moonshot.cn/v1",
+        apiKey: "",
+        alias: "kimi",
+      },
+      qwen: {
+        providerId: "qwen",
+        modelId: "qwen-plus",
+        baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+        apiKey: "",
+        alias: "qwen",
+      },
+      feishu: {
+        enabled: true,
+        appId: "",
+        appSecret: "",
+        encryptKey: "",
+        verificationToken: "",
+        domainMode: "feishu",
+        customDomain: "",
+        connectionMode: "websocket",
+        webhookPath: "/feishu/events",
+        dmPolicy: "open",
+        allowFrom: ["user-1"],
+        groupPolicy: "allowlist",
+        groupAllowFrom: [],
+        requireMention: true,
+      },
+    });
+
+    const feishu = next.channels?.feishu as { allowFrom?: string[] } | undefined;
+    expect(feishu?.allowFrom).toContain("*");
+    expect(feishu?.allowFrom).toContain("user-1");
+  });
+
+  test("applyPortalPayload preserves existing secrets when payload leaves them empty", () => {
+    const next = applyPortalPayload(
+      {
+        models: {
+          providers: {
+            "kimi-coding": {
+              baseUrl: "https://api.moonshot.cn/v1",
+              api: "openai-completions",
+              apiKey: "old-kimi-key",
+              models: [],
+            },
+          },
+        },
+        channels: {
+          feishu: {
+            appSecret: "old-secret",
+            encryptKey: "old-encrypt",
+            verificationToken: "old-token",
+          },
+        },
+      } as OpenClawConfig,
+      {
+        activeModelProvider: "kimi",
+        kimi: {
+          providerId: "custom-kimi-id",
+          modelId: "kimi-k2.5-coding-preview",
+          baseUrl: "https://api.moonshot.cn/v1",
+          apiKey: "",
+          alias: "kimi",
+        },
+        qwen: {
+          providerId: "custom-qwen-id",
+          modelId: "qwen-plus",
+          baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+          apiKey: "",
+          alias: "qwen",
+        },
+        feishu: {
+          enabled: true,
+          appId: "app-id",
+          appSecret: "",
+          encryptKey: "",
+          verificationToken: "",
+          domainMode: "feishu",
+          customDomain: "",
+          connectionMode: "websocket",
+          webhookPath: "/feishu/events",
+          dmPolicy: "pairing",
+          allowFrom: [],
+          groupPolicy: "allowlist",
+          groupAllowFrom: [],
+          requireMention: true,
+        },
+      },
+    );
+
+    expect(next.models?.providers?.["kimi-coding"]?.apiKey).toBe("old-kimi-key");
+    const feishu = next.channels?.feishu as
+      | { appSecret?: string; encryptKey?: string; verificationToken?: string }
+      | undefined;
+    expect(feishu?.appSecret).toBe("old-secret");
+    expect(feishu?.encryptKey).toBe("old-encrypt");
+    expect(feishu?.verificationToken).toBe("old-token");
+  });
+});

package/src/config-state.ts

@@ -0,0 +1,508 @@
+import type { ModelDefinitionConfig, ModelProviderConfig, OpenClawConfig } from "openclaw/plugin-sdk";
+
+const DEFAULT_KIMI_PROVIDER_ID = "kimi-coding";
+const DEFAULT_QWEN_PROVIDER_ID = "qwen";
+
+const DEFAULT_KIMI_MODEL_ID = "kimi-k2.5-coding-preview";
+const DEFAULT_QWEN_MODEL_ID = "qwen-plus";
+
+const DEFAULT_KIMI_BASE_URL = "https://api.moonshot.cn/v1";
+const DEFAULT_QWEN_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+
+const DEFAULT_KIMI_ALIAS = "kimi";
+const DEFAULT_QWEN_ALIAS = "qwen";
+
+const DEFAULT_CONTEXT_WINDOW = 128000;
+const DEFAULT_MAX_TOKENS = 8192;
+
+const DEFAULT_FEISHU_WEBHOOK_PATH = "/feishu/events";
+
+export type PortalProviderKey = "kimi" | "qwen";
+export type FeishuDomainMode = "feishu" | "lark" | "custom";
+export type FeishuConnectionMode = "websocket" | "webhook";
+export type FeishuDmPolicy = "open" | "pairing" | "allowlist";
+export type FeishuGroupPolicy = "open" | "allowlist" | "disabled";
+
+export type PortalProviderConfigInput = {
+  providerId: string;
+  modelId: string;
+  baseUrl: string;
+  apiKey: string;
+  alias: string;
+};
+
+export type PortalFeishuConfigInput = {
+  enabled: boolean;
+  appId: string;
+  appSecret: string;
+  encryptKey: string;
+  verificationToken: string;
+  domainMode: FeishuDomainMode;
+  customDomain: string;
+  connectionMode: FeishuConnectionMode;
+  webhookPath: string;
+  dmPolicy: FeishuDmPolicy;
+  allowFrom: string[];
+  groupPolicy: FeishuGroupPolicy;
+  groupAllowFrom: string[];
+  requireMention: boolean;
+};
+
+export type PortalConfigPayload = {
+  activeModelProvider: PortalProviderKey;
+  kimi: PortalProviderConfigInput;
+  qwen: PortalProviderConfigInput;
+  feishu: PortalFeishuConfigInput;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function asString(value: unknown, fallback = ""): string {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  return value.trim();
+}
+
+function asBoolean(value: unknown, fallback = false): boolean {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return fallback;
+}
+
+function asEnum<T extends string>(value: unknown, allowed: readonly T[], fallback: T): T {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const normalized = value.trim();
+  return (allowed as readonly string[]).includes(normalized) ? (normalized as T) : fallback;
+}
+
+function asStringList(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .map((entry) => String(entry).trim())
+    .filter((entry) => entry.length > 0);
+}
+
+function parseModelRef(value: string | undefined): { providerId: string; modelId: string } | null {
+  if (!value) {
+    return null;
+  }
+  const slashIndex = value.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= value.length - 1) {
+    return null;
+  }
+  return {
+    providerId: value.slice(0, slashIndex),
+    modelId: value.slice(slashIndex + 1),
+  };
+}
+
+function normalizeBaseUrl(value: string, fallback: string): string {
+  const raw = value.trim() || fallback;
+  const withProtocol = raw.startsWith("http://") || raw.startsWith("https://") ? raw : `https://${raw}`;
+  const withoutTrailingSlash = withProtocol.replace(/\/+$/, "");
+  return withoutTrailingSlash.endsWith("/v1") ? withoutTrailingSlash : `${withoutTrailingSlash}/v1`;
+}
+
+function cleanStringList(values: string[]): string[] {
+  return values
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+}
+
+function resolvePrimaryModel(cfg: OpenClawConfig): string | undefined {
+  const modelConfig = cfg.agents?.defaults?.model;
+  if (!isRecord(modelConfig)) {
+    return undefined;
+  }
+  const primary = modelConfig.primary;
+  return typeof primary === "string" && primary.trim() ? primary.trim() : undefined;
+}
+
+function readProvider(cfg: OpenClawConfig, providerId: string): ModelProviderConfig | undefined {
+  const providers = cfg.models?.providers;
+  if (!providers) {
+    return undefined;
+  }
+  return providers[providerId];
+}
+
+function pickProviderModelId(params: {
+  cfg: OpenClawConfig;
+  providerId: string;
+  fallbackModelId: string;
+}): string {
+  const primary = resolvePrimaryModel(params.cfg);
+  const primaryRef = parseModelRef(primary);
+  if (primaryRef?.providerId === params.providerId) {
+    return primaryRef.modelId;
+  }
+
+  const provider = readProvider(params.cfg, params.providerId);
+  const first = provider?.models?.[0]?.id;
+  return typeof first === "string" && first.trim() ? first.trim() : params.fallbackModelId;
+}
+
+function resolveAlias(cfg: OpenClawConfig, modelRef: string, fallback: string): string {
+  const modelEntry = cfg.agents?.defaults?.models?.[modelRef];
+  const alias = modelEntry?.alias;
+  return typeof alias === "string" && alias.trim() ? alias.trim() : fallback;
+}
+
+function resolveFeishuDomainMode(domainValue: string): FeishuDomainMode {
+  if (domainValue === "feishu" || domainValue === "lark") {
+    return domainValue;
+  }
+  return "custom";
+}
+
+function buildModelDefinition(params: { id: string; name: string }): ModelDefinitionConfig {
+  return {
+    id: params.id,
+    name: params.name,
+    reasoning: false,
+    input: ["text"],
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+    },
+    contextWindow: DEFAULT_CONTEXT_WINDOW,
+    maxTokens: DEFAULT_MAX_TOKENS,
+  };
+}
+
+function upsertModel(models: ModelDefinitionConfig[], next: ModelDefinitionConfig): ModelDefinitionConfig[] {
+  const index = models.findIndex((model) => model.id === next.id);
+  if (index === -1) {
+    return [...models, next];
+  }
+  const cloned = [...models];
+  cloned[index] = {
+    ...cloned[index],
+    ...next,
+  };
+  return cloned;
+}
+
+function withOptionalStringKey(target: Record<string, unknown>, key: string, value: string): void {
+  if (!value) {
+    delete target[key];
+    return;
+  }
+  target[key] = value;
+}
+
+function withSecretStringKey(target: Record<string, unknown>, key: string, value: string): void {
+  if (!value) {
+    return;
+  }
+  target[key] = value;
+}
+
+function buildProviderConfig(params: {
+  existing?: ModelProviderConfig;
+  modelId: string;
+  modelName: string;
+  baseUrl: string;
+  apiKey: string;
+}): ModelProviderConfig {
+  const existing = params.existing;
+  const nextModel = buildModelDefinition({
+    id: params.modelId,
+    name: params.modelName,
+  });
+  const existingModels = Array.isArray(existing?.models) ? existing.models : [];
+  const models = upsertModel(existingModels, nextModel);
+
+  const next: ModelProviderConfig = {
+    ...existing,
+    api: "openai-completions",
+    baseUrl: params.baseUrl,
+    models,
+  };
+
+  const apiKey = params.apiKey.trim();
+  if (apiKey) {
+    next.apiKey = apiKey;
+  }
+
+  return next;
+}
+
+function inferActiveProvider(params: {
+  cfg: OpenClawConfig;
+  kimiProviderId: string;
+  qwenProviderId: string;
+}): PortalProviderKey {
+  const primaryRef = parseModelRef(resolvePrimaryModel(params.cfg));
+  if (primaryRef?.providerId === params.kimiProviderId) {
+    return "kimi";
+  }
+  if (primaryRef?.providerId === params.qwenProviderId) {
+    return "qwen";
+  }
+
+  const hasQwen = Boolean(readProvider(params.cfg, params.qwenProviderId));
+  if (hasQwen) {
+    return "qwen";
+  }
+  return "kimi";
+}
+
+function normalizePayload(input: unknown): PortalConfigPayload {
+  if (!isRecord(input)) {
+    throw new Error("Invalid payload: expected object.");
+  }
+
+  const activeModelProvider = asEnum(input.activeModelProvider, ["kimi", "qwen"], "kimi");
+  const kimiRaw = isRecord(input.kimi) ? input.kimi : {};
+  const qwenRaw = isRecord(input.qwen) ? input.qwen : {};
+  const feishuRaw = isRecord(input.feishu) ? input.feishu : {};
+
+  const normalized: PortalConfigPayload = {
+    activeModelProvider,
+    kimi: {
+      providerId: DEFAULT_KIMI_PROVIDER_ID,
+      modelId: asString(kimiRaw.modelId, DEFAULT_KIMI_MODEL_ID),
+      baseUrl: asString(kimiRaw.baseUrl, DEFAULT_KIMI_BASE_URL),
+      apiKey: asString(kimiRaw.apiKey),
+      alias: asString(kimiRaw.alias, DEFAULT_KIMI_ALIAS),
+    },
+    qwen: {
+      providerId: DEFAULT_QWEN_PROVIDER_ID,
+      modelId: asString(qwenRaw.modelId, DEFAULT_QWEN_MODEL_ID),
+      baseUrl: asString(qwenRaw.baseUrl, DEFAULT_QWEN_BASE_URL),
+      apiKey: asString(qwenRaw.apiKey),
+      alias: asString(qwenRaw.alias, DEFAULT_QWEN_ALIAS),
+    },
+    feishu: {
+      enabled: asBoolean(feishuRaw.enabled, false),
+      appId: asString(feishuRaw.appId),
+      appSecret: asString(feishuRaw.appSecret),
+      encryptKey: asString(feishuRaw.encryptKey),
+      verificationToken: asString(feishuRaw.verificationToken),
+      domainMode: asEnum(feishuRaw.domainMode, ["feishu", "lark", "custom"], "feishu"),
+      customDomain: asString(feishuRaw.customDomain),
+      connectionMode: asEnum(feishuRaw.connectionMode, ["websocket", "webhook"], "websocket"),
+      webhookPath: asString(feishuRaw.webhookPath, DEFAULT_FEISHU_WEBHOOK_PATH),
+      dmPolicy: asEnum(feishuRaw.dmPolicy, ["open", "pairing", "allowlist"], "pairing"),
+      allowFrom: asStringList(feishuRaw.allowFrom),
+      groupPolicy: asEnum(feishuRaw.groupPolicy, ["open", "allowlist", "disabled"], "allowlist"),
+      groupAllowFrom: asStringList(feishuRaw.groupAllowFrom),
+      requireMention: asBoolean(feishuRaw.requireMention, true),
+    },
+  };
+
+  if (!normalized.kimi.modelId) {
+    normalized.kimi.modelId = DEFAULT_KIMI_MODEL_ID;
+  }
+  if (!normalized.kimi.baseUrl) {
+    normalized.kimi.baseUrl = DEFAULT_KIMI_BASE_URL;
+  }
+  if (!normalized.kimi.alias) {
+    normalized.kimi.alias = DEFAULT_KIMI_ALIAS;
+  }
+
+  if (!normalized.qwen.modelId) {
+    normalized.qwen.modelId = DEFAULT_QWEN_MODEL_ID;
+  }
+  if (!normalized.qwen.baseUrl) {
+    normalized.qwen.baseUrl = DEFAULT_QWEN_BASE_URL;
+  }
+  if (!normalized.qwen.alias) {
+    normalized.qwen.alias = DEFAULT_QWEN_ALIAS;
+  }
+
+  if (!normalized.feishu.webhookPath) {
+    normalized.feishu.webhookPath = DEFAULT_FEISHU_WEBHOOK_PATH;
+  }
+
+  return normalized;
+}
+
+export function buildPortalSnapshot(cfg: OpenClawConfig): PortalConfigPayload {
+  const kimiProvider = readProvider(cfg, DEFAULT_KIMI_PROVIDER_ID);
+  const qwenProvider = readProvider(cfg, DEFAULT_QWEN_PROVIDER_ID);
+
+  const kimiModelId = pickProviderModelId({
+    cfg,
+    providerId: DEFAULT_KIMI_PROVIDER_ID,
+    fallbackModelId: DEFAULT_KIMI_MODEL_ID,
+  });
+  const qwenModelId = pickProviderModelId({
+    cfg,
+    providerId: DEFAULT_QWEN_PROVIDER_ID,
+    fallbackModelId: DEFAULT_QWEN_MODEL_ID,
+  });
+
+  const kimiModelRef = `${DEFAULT_KIMI_PROVIDER_ID}/${kimiModelId}`;
+  const qwenModelRef = `${DEFAULT_QWEN_PROVIDER_ID}/${qwenModelId}`;
+
+  const feishuConfig = isRecord(cfg.channels?.feishu) ? cfg.channels?.feishu : {};
+  const feishuDomainRaw = asString(feishuConfig.domain, "feishu");
+
+  return {
+    activeModelProvider: inferActiveProvider({
+      cfg,
+      kimiProviderId: DEFAULT_KIMI_PROVIDER_ID,
+      qwenProviderId: DEFAULT_QWEN_PROVIDER_ID,
+    }),
+    kimi: {
+      providerId: DEFAULT_KIMI_PROVIDER_ID,
+      modelId: kimiModelId,
+      baseUrl: kimiProvider?.baseUrl ?? DEFAULT_KIMI_BASE_URL,
+      apiKey: "",
+      alias: resolveAlias(cfg, kimiModelRef, DEFAULT_KIMI_ALIAS),
+    },
+    qwen: {
+      providerId: DEFAULT_QWEN_PROVIDER_ID,
+      modelId: qwenModelId,
+      baseUrl: qwenProvider?.baseUrl ?? DEFAULT_QWEN_BASE_URL,
+      apiKey: "",
+      alias: resolveAlias(cfg, qwenModelRef, DEFAULT_QWEN_ALIAS),
+    },
+    feishu: {
+      enabled: asBoolean(feishuConfig.enabled, false),
+      appId: asString(feishuConfig.appId),
+      appSecret: "",
+      encryptKey: "",
+      verificationToken: "",
+      domainMode: resolveFeishuDomainMode(feishuDomainRaw),
+      customDomain: resolveFeishuDomainMode(feishuDomainRaw) === "custom" ? feishuDomainRaw : "",
+      connectionMode: asEnum(feishuConfig.connectionMode, ["websocket", "webhook"], "websocket"),
+      webhookPath: asString(feishuConfig.webhookPath, DEFAULT_FEISHU_WEBHOOK_PATH),
+      dmPolicy: asEnum(feishuConfig.dmPolicy, ["open", "pairing", "allowlist"], "pairing"),
+      allowFrom: asStringList(feishuConfig.allowFrom),
+      groupPolicy: asEnum(feishuConfig.groupPolicy, ["open", "allowlist", "disabled"], "allowlist"),
+      groupAllowFrom: asStringList(feishuConfig.groupAllowFrom),
+      requireMention: asBoolean(feishuConfig.requireMention, true),
+    },
+  };
+}
+
+export function applyPortalPayload(cfg: OpenClawConfig, input: unknown): OpenClawConfig {
+  const payload = normalizePayload(input);
+
+  const kimiProviderId = payload.kimi.providerId;
+  const qwenProviderId = payload.qwen.providerId;
+  const kimiModelRef = `${kimiProviderId}/${payload.kimi.modelId}`;
+  const qwenModelRef = `${qwenProviderId}/${payload.qwen.modelId}`;
+
+  const nextProviders: Record<string, ModelProviderConfig> = {
+    ...(cfg.models?.providers ?? {}),
+    [kimiProviderId]: buildProviderConfig({
+      existing: readProvider(cfg, kimiProviderId),
+      modelId: payload.kimi.modelId,
+      modelName: "Kimi Coding K2.5",
+      baseUrl: normalizeBaseUrl(payload.kimi.baseUrl, DEFAULT_KIMI_BASE_URL),
+      apiKey: payload.kimi.apiKey,
+    }),
+    [qwenProviderId]: buildProviderConfig({
+      existing: readProvider(cfg, qwenProviderId),
+      modelId: payload.qwen.modelId,
+      modelName: "Qwen",
+      baseUrl: normalizeBaseUrl(payload.qwen.baseUrl, DEFAULT_QWEN_BASE_URL),
+      apiKey: payload.qwen.apiKey,
+    }),
+  };
+
+  const existingDefaults = cfg.agents?.defaults;
+  const existingModel = isRecord(existingDefaults?.model) ? existingDefaults.model : {};
+  const fallbacks = Array.isArray(existingModel.fallbacks)
+    ? existingModel.fallbacks.filter((item): item is string => typeof item === "string")
+    : [];
+
+  const nextDefaultPrimary = payload.activeModelProvider === "qwen" ? qwenModelRef : kimiModelRef;
+
+  const nextModels = {
+    ...(existingDefaults?.models ?? {}),
+    [kimiModelRef]: {
+      ...(existingDefaults?.models?.[kimiModelRef] ?? {}),
+      alias: payload.kimi.alias,
+    },
+    [qwenModelRef]: {
+      ...(existingDefaults?.models?.[qwenModelRef] ?? {}),
+      alias: payload.qwen.alias,
+    },
+  };
+
+  const feishuDomain =
+    payload.feishu.domainMode === "custom"
+      ? payload.feishu.customDomain || "feishu"
+      : payload.feishu.domainMode;
+
+  const allowFrom = cleanStringList(payload.feishu.allowFrom);
+  if (payload.feishu.dmPolicy === "open" && !allowFrom.includes("*")) {
+    allowFrom.push("*");
+  }
+  const groupAllowFrom = cleanStringList(payload.feishu.groupAllowFrom);
+
+  const existingFeishu = isRecord(cfg.channels?.feishu) ? { ...cfg.channels?.feishu } : {};
+  withOptionalStringKey(existingFeishu, "appId", payload.feishu.appId);
+  withSecretStringKey(existingFeishu, "appSecret", payload.feishu.appSecret);
+  withSecretStringKey(existingFeishu, "encryptKey", payload.feishu.encryptKey);
+  withSecretStringKey(existingFeishu, "verificationToken", payload.feishu.verificationToken);
+
+  existingFeishu.enabled = payload.feishu.enabled;
+  existingFeishu.domain = feishuDomain;
+  existingFeishu.connectionMode = payload.feishu.connectionMode;
+  existingFeishu.webhookPath = payload.feishu.webhookPath || DEFAULT_FEISHU_WEBHOOK_PATH;
+  existingFeishu.dmPolicy = payload.feishu.dmPolicy;
+  existingFeishu.groupPolicy = payload.feishu.groupPolicy;
+  existingFeishu.requireMention = payload.feishu.requireMention;
+
+  if (allowFrom.length > 0) {
+    existingFeishu.allowFrom = allowFrom;
+  } else {
+    delete existingFeishu.allowFrom;
+  }
+
+  if (groupAllowFrom.length > 0) {
+    existingFeishu.groupAllowFrom = groupAllowFrom;
+  } else {
+    delete existingFeishu.groupAllowFrom;
+  }
+
+  const pluginsEntries = isRecord(cfg.plugins?.entries) ? { ...cfg.plugins?.entries } : {};
+  if (payload.feishu.enabled) {
+    const feishuPluginEntry = isRecord(pluginsEntries.feishu) ? { ...pluginsEntries.feishu } : {};
+    feishuPluginEntry.enabled = true;
+    pluginsEntries.feishu = feishuPluginEntry;
+  }
+
+  return {
+    ...cfg,
+    models: {
+      ...(cfg.models ?? {}),
+      providers: nextProviders,
+    },
+    agents: {
+      ...(cfg.agents ?? {}),
+      defaults: {
+        ...(existingDefaults ?? {}),
+        models: nextModels,
+        model: {
+          ...(fallbacks.length > 0 ? { fallbacks } : {}),
+          primary: nextDefaultPrimary,
+        },
+      },
+    },
+    channels: {
+      ...(cfg.channels ?? {}),
+      feishu: existingFeishu,
+    },
+    plugins: {
+      ...(cfg.plugins ?? {}),
+      entries: pluginsEntries,
+    },
+  };
+}

package/web/index.html

@@ -0,0 +1,488 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>OpenClaw 配置门户</title>
+    <style>
+      :root {
+        --bg: #f6f8f5;
+        --panel: #ffffff;
+        --ink: #14211a;
+        --muted: #5f6d63;
+        --line: #d5dfd7;
+        --brand: #1c7a45;
+        --brand-soft: #e6f4eb;
+        --warn: #a93b2f;
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        font-family: "IBM Plex Sans", "Noto Sans SC", "PingFang SC", "Hiragino Sans GB", sans-serif;
+        color: var(--ink);
+        background:
+          radial-gradient(circle at 20% -10%, #dcefd9 0%, #f6f8f5 45%),
+          linear-gradient(180deg, #f6f8f5 0%, #eef4ef 100%);
+      }
+
+      .layout {
+        max-width: 980px;
+        margin: 0 auto;
+        padding: 28px 16px 48px;
+      }
+
+      .hero {
+        margin-bottom: 16px;
+      }
+
+      h1 {
+        margin: 0 0 10px;
+        font-size: clamp(26px, 4.5vw, 40px);
+        letter-spacing: 0.02em;
+      }
+
+      .sub {
+        color: var(--muted);
+        margin: 0;
+      }
+
+      .panel {
+        background: var(--panel);
+        border: 1px solid var(--line);
+        border-radius: 16px;
+        padding: 16px;
+        margin-top: 16px;
+        box-shadow: 0 8px 24px rgba(16, 33, 24, 0.06);
+      }
+
+      .panel h2 {
+        margin: 0 0 14px;
+        font-size: 18px;
+      }
+
+      .grid-2 {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 12px;
+      }
+
+      @media (max-width: 820px) {
+        .grid-2 {
+          grid-template-columns: 1fr;
+        }
+      }
+
+      label {
+        display: block;
+        font-weight: 600;
+        font-size: 13px;
+        margin-bottom: 6px;
+      }
+
+      .field {
+        margin-bottom: 10px;
+      }
+
+      input,
+      select,
+      textarea {
+        width: 100%;
+        border: 1px solid var(--line);
+        border-radius: 10px;
+        padding: 9px 10px;
+        font: inherit;
+        color: inherit;
+        background: #fff;
+      }
+
+      textarea {
+        min-height: 84px;
+        resize: vertical;
+      }
+
+      .inline {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+      }
+
+      .inline label {
+        margin: 0;
+      }
+
+      .switches {
+        display: flex;
+        gap: 16px;
+        flex-wrap: wrap;
+        margin: 8px 0 4px;
+      }
+
+      .switches .inline {
+        background: var(--brand-soft);
+        padding: 8px 10px;
+        border-radius: 10px;
+      }
+
+      .actions {
+        display: flex;
+        gap: 10px;
+        align-items: center;
+        margin-top: 14px;
+      }
+
+      button {
+        border: none;
+        border-radius: 10px;
+        padding: 10px 14px;
+        font: inherit;
+        font-weight: 600;
+        cursor: pointer;
+        background: var(--brand);
+        color: #fff;
+      }
+
+      button:disabled {
+        opacity: 0.65;
+        cursor: not-allowed;
+      }
+
+      .status {
+        font-size: 13px;
+      }
+
+      .status[data-level="ok"] {
+        color: var(--brand);
+      }
+
+      .status[data-level="error"] {
+        color: var(--warn);
+      }
+
+      .hint {
+        color: var(--muted);
+        font-size: 12px;
+        margin-top: 6px;
+      }
+    </style>
+  </head>
+  <body>
+    <main class="layout">
+      <header class="hero">
+        <h1>OpenClaw 配置门户</h1>
+        <p class="sub">配置 Kimi Coding K2.5 / 千问模型并切换默认模型，同时设置飞书渠道。</p>
+      </header>
+
+      <section class="panel">
+        <h2>模型切换</h2>
+        <div class="switches">
+          <div class="inline">
+            <input id="active-kimi" type="radio" name="active-model" value="kimi" />
+            <label for="active-kimi">默认模型: Kimi</label>
+          </div>
+          <div class="inline">
+            <input id="active-qwen" type="radio" name="active-model" value="qwen" />
+            <label for="active-qwen">默认模型: 千问</label>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <h2>Kimi Coding K2.5</h2>
+        <div class="grid-2">
+          <div>
+            <div class="field">
+              <label for="kimi-model-id">Model ID</label>
+              <input id="kimi-model-id" />
+            </div>
+            <div class="field">
+              <label for="kimi-alias">Alias</label>
+              <input id="kimi-alias" />
+            </div>
+          </div>
+          <div>
+            <div class="field">
+              <label for="kimi-base-url">Base URL</label>
+              <input id="kimi-base-url" />
+            </div>
+            <div class="field">
+              <label for="kimi-api-key">API Key</label>
+              <input id="kimi-api-key" type="password" autocomplete="off" />
+              <div class="hint">留空表示保持当前 API Key。</div>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <h2>千问 (Qwen)</h2>
+        <div class="grid-2">
+          <div>
+            <div class="field">
+              <label for="qwen-model-id">Model ID</label>
+              <input id="qwen-model-id" />
+            </div>
+            <div class="field">
+              <label for="qwen-alias">Alias</label>
+              <input id="qwen-alias" />
+            </div>
+          </div>
+          <div>
+            <div class="field">
+              <label for="qwen-base-url">Base URL</label>
+              <input id="qwen-base-url" />
+            </div>
+            <div class="field">
+              <label for="qwen-api-key">API Key</label>
+              <input id="qwen-api-key" type="password" autocomplete="off" />
+              <div class="hint">留空表示保持当前 API Key。</div>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <h2>飞书渠道 (Feishu)</h2>
+        <div class="field inline">
+          <input id="feishu-enabled" type="checkbox" />
+          <label for="feishu-enabled">启用飞书渠道</label>
+        </div>
+        <div class="grid-2">
+          <div>
+            <div class="field">
+              <label for="feishu-app-id">App ID</label>
+              <input id="feishu-app-id" />
+            </div>
+            <div class="field">
+              <label for="feishu-app-secret">App Secret</label>
+              <input id="feishu-app-secret" type="password" autocomplete="off" />
+              <div class="hint">留空表示保持当前 App Secret。</div>
+            </div>
+            <div class="field">
+              <label for="feishu-encrypt-key">Encrypt Key</label>
+              <input id="feishu-encrypt-key" />
+              <div class="hint">留空表示保持当前 Encrypt Key。</div>
+            </div>
+            <div class="field">
+              <label for="feishu-verification-token">Verification Token</label>
+              <input id="feishu-verification-token" />
+              <div class="hint">留空表示保持当前 Verification Token。</div>
+            </div>
+          </div>
+          <div>
+            <div class="field">
+              <label for="feishu-domain-mode">Domain</label>
+              <select id="feishu-domain-mode">
+                <option value="feishu">feishu</option>
+                <option value="lark">lark</option>
+                <option value="custom">自定义 HTTPS 域名</option>
+              </select>
+            </div>
+            <div class="field">
+              <label for="feishu-custom-domain">Custom Domain</label>
+              <input id="feishu-custom-domain" placeholder="https://open.feishu.cn" />
+            </div>
+            <div class="field">
+              <label for="feishu-connection-mode">Connection Mode</label>
+              <select id="feishu-connection-mode">
+                <option value="websocket">websocket</option>
+                <option value="webhook">webhook</option>
+              </select>
+            </div>
+            <div class="field">
+              <label for="feishu-webhook-path">Webhook Path</label>
+              <input id="feishu-webhook-path" />
+            </div>
+          </div>
+        </div>
+
+        <div class="grid-2">
+          <div>
+            <div class="field">
+              <label for="feishu-dm-policy">DM Policy</label>
+              <select id="feishu-dm-policy">
+                <option value="pairing">pairing</option>
+                <option value="allowlist">allowlist</option>
+                <option value="open">open</option>
+              </select>
+            </div>
+            <div class="field">
+              <label for="feishu-allow-from">allowFrom (逗号/换行分隔)</label>
+              <textarea id="feishu-allow-from"></textarea>
+            </div>
+          </div>
+          <div>
+            <div class="field">
+              <label for="feishu-group-policy">Group Policy</label>
+              <select id="feishu-group-policy">
+                <option value="allowlist">allowlist</option>
+                <option value="open">open</option>
+                <option value="disabled">disabled</option>
+              </select>
+            </div>
+            <div class="field">
+              <label for="feishu-group-allow-from">groupAllowFrom (逗号/换行分隔)</label>
+              <textarea id="feishu-group-allow-from"></textarea>
+            </div>
+            <div class="field inline">
+              <input id="feishu-require-mention" type="checkbox" />
+              <label for="feishu-require-mention">群聊必须 @ 提及才响应</label>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="actions">
+          <button id="save-button">保存配置</button>
+          <span class="status" id="status"></span>
+        </div>
+        <p class="hint">保存后请重启 Gateway，模型与渠道运行时配置才会生效。</p>
+      </section>
+    </main>
+
+    <script>
+      const state = {
+        apiPath: "",
+      };
+
+      const $ = (id) => document.getElementById(id);
+      const statusEl = $("status");
+      const saveButton = $("save-button");
+
+      function toList(text) {
+        return text
+          .split(/\n|,/)
+          .map((item) => item.trim())
+          .filter(Boolean);
+      }
+
+      function listToText(values) {
+        if (!Array.isArray(values) || values.length === 0) {
+          return "";
+        }
+        return values.join("\n");
+      }
+
+      function setStatus(message, level) {
+        statusEl.textContent = message || "";
+        statusEl.dataset.level = level || "";
+      }
+
+      function fillForm(config) {
+        $("active-kimi").checked = config.activeModelProvider === "kimi";
+        $("active-qwen").checked = config.activeModelProvider === "qwen";
+
+        $("kimi-model-id").value = config.kimi.modelId || "";
+        $("kimi-base-url").value = config.kimi.baseUrl || "";
+        $("kimi-api-key").value = config.kimi.apiKey || "";
+        $("kimi-alias").value = config.kimi.alias || "";
+
+        $("qwen-model-id").value = config.qwen.modelId || "";
+        $("qwen-base-url").value = config.qwen.baseUrl || "";
+        $("qwen-api-key").value = config.qwen.apiKey || "";
+        $("qwen-alias").value = config.qwen.alias || "";
+
+        $("feishu-enabled").checked = Boolean(config.feishu.enabled);
+        $("feishu-app-id").value = config.feishu.appId || "";
+        $("feishu-app-secret").value = config.feishu.appSecret || "";
+        $("feishu-encrypt-key").value = config.feishu.encryptKey || "";
+        $("feishu-verification-token").value = config.feishu.verificationToken || "";
+        $("feishu-domain-mode").value = config.feishu.domainMode || "feishu";
+        $("feishu-custom-domain").value = config.feishu.customDomain || "";
+        $("feishu-connection-mode").value = config.feishu.connectionMode || "websocket";
+        $("feishu-webhook-path").value = config.feishu.webhookPath || "/feishu/events";
+        $("feishu-dm-policy").value = config.feishu.dmPolicy || "pairing";
+        $("feishu-allow-from").value = listToText(config.feishu.allowFrom);
+        $("feishu-group-policy").value = config.feishu.groupPolicy || "allowlist";
+        $("feishu-group-allow-from").value = listToText(config.feishu.groupAllowFrom);
+        $("feishu-require-mention").checked =
+          config.feishu.requireMention === undefined ? true : Boolean(config.feishu.requireMention);
+      }
+
+      function buildPayload() {
+        return {
+          activeModelProvider: $("active-qwen").checked ? "qwen" : "kimi",
+          kimi: {
+            modelId: $("kimi-model-id").value.trim(),
+            baseUrl: $("kimi-base-url").value.trim(),
+            apiKey: $("kimi-api-key").value.trim(),
+            alias: $("kimi-alias").value.trim(),
+          },
+          qwen: {
+            modelId: $("qwen-model-id").value.trim(),
+            baseUrl: $("qwen-base-url").value.trim(),
+            apiKey: $("qwen-api-key").value.trim(),
+            alias: $("qwen-alias").value.trim(),
+          },
+          feishu: {
+            enabled: $("feishu-enabled").checked,
+            appId: $("feishu-app-id").value.trim(),
+            appSecret: $("feishu-app-secret").value.trim(),
+            encryptKey: $("feishu-encrypt-key").value.trim(),
+            verificationToken: $("feishu-verification-token").value.trim(),
+            domainMode: $("feishu-domain-mode").value,
+            customDomain: $("feishu-custom-domain").value.trim(),
+            connectionMode: $("feishu-connection-mode").value,
+            webhookPath: $("feishu-webhook-path").value.trim(),
+            dmPolicy: $("feishu-dm-policy").value,
+            allowFrom: toList($("feishu-allow-from").value),
+            groupPolicy: $("feishu-group-policy").value,
+            groupAllowFrom: toList($("feishu-group-allow-from").value),
+            requireMention: $("feishu-require-mention").checked,
+          },
+        };
+      }
+
+      async function loadConfig() {
+        setStatus("正在加载配置...", "");
+        const response = await fetch(state.apiPath, { method: "GET" });
+        const data = await response.json();
+        if (!response.ok || !data.ok) {
+          throw new Error(data.error || "读取配置失败");
+        }
+        fillForm(data.config);
+        setStatus("配置已加载", "ok");
+      }
+
+      async function saveConfig() {
+        saveButton.disabled = true;
+        setStatus("正在保存...", "");
+        try {
+          const response = await fetch(state.apiPath, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify(buildPayload()),
+          });
+          const data = await response.json();
+          if (!response.ok || !data.ok) {
+            throw new Error(data.error || "保存失败");
+          }
+          fillForm(data.config);
+          setStatus(data.message || "保存成功", "ok");
+        } catch (error) {
+          setStatus(error instanceof Error ? error.message : String(error), "error");
+        } finally {
+          saveButton.disabled = false;
+        }
+      }
+
+      function resolveApiPath() {
+        const pathname = location.pathname.replace(/\/+$/, "");
+        return `${pathname}/api/config`;
+      }
+
+      saveButton.addEventListener("click", () => {
+        void saveConfig();
+      });
+
+      state.apiPath = resolveApiPath();
+      void loadConfig();
+    </script>
+  </body>
+</html>