feat: add PLUS_API_KEY validation and Plus host switching.

Author: qorzj

docs/configuration.md

@@ -286,6 +286,6 @@ PLUS 独立配置文件为 `~/.deepcode-plus/settings.json`：
 
 `subscriptionPlan` 支持 `default`、`on`、`off`；缺失或非法值按 `default` 处理。普通通道继续使用上文配置层级合并后的 API key 和 base URL。
 
-- `default`：未配置 PLUS key 时使用普通通道；否则每次创建或回复会话前，用 PLUS key 请求 `GET https://deepcode.vegamo.cn/plugin/openai/models`。200 表示 `full ability`，使用 PLUS；401/403 表示 `api only`，使用普通通道（普通 key 缺失也不回退 PLUS）。其他 HTTP 状态、网络异常或 3 秒超时表示 `unknown`：优先普通 key，未配置普通 key 时使用 PLUS。
-- `on`：直接使用 PLUS key 和 `https://deepcode.vegamo.cn/plugin/openai`，不执行订阅检查。缺少 PLUS key 时明确报错，不回退普通通道。
+- `default`：如果开通了DeepCode Plus订阅，则相当于`on`，否则相当于`off`。
+- `on`：直接使用 PLUS key，不执行订阅检查。缺少 PLUS key 时明确报错，不回退普通通道。
 - `off`：固定使用普通通道，不执行订阅检查。

docs/configuration_en.md

@@ -285,6 +285,6 @@ Configure PLUS separately in `~/.deepcode-plus/settings.json`:
 
 `subscriptionPlan` accepts `default`, `on`, or `off`; missing or invalid values use `default`. The regular connection retains the user/project/environment precedence described above.
 
-- `default`: Without a PLUS key, use the regular connection. Otherwise, before each session creation or reply, request `GET https://deepcode.vegamo.cn/plugin/openai/models` with the PLUS key. HTTP 200 means `full ability` and selects PLUS. HTTP 401/403 means `api only` and selects the regular connection, even if its key is missing. Other HTTP statuses, network errors, and a 3-second timeout mean `unknown`: prefer the regular key if configured, otherwise use PLUS.
-- `on`: Use the PLUS key with `https://deepcode.vegamo.cn/plugin/openai` directly, without a subscription check. A missing PLUS key produces an explicit error without falling back.
+- `default`: If you have a DeepCode Plus subscription, it's considered `on`; otherwise, it's considered `off`.
+- `on`: Use the PLUS key, without a subscription check. A missing PLUS key produces an explicit error without falling back.
 - `off`: Always use the regular connection without checking the subscription.

packages/cli/src/ui/views/App.tsx

@@ -256,7 +256,11 @@ function App({ projectRoot, initialPrompt, resumeSessionId, forkSessionId, onRes
   // warmup (fire-and-forget inside createOpenAIClient) starts before the
   // user sends their first prompt.
   useEffect(() => {
-    clientFactory();
+    try {
+      clientFactory();
+    } catch (error) {
+      setErrorLine(error instanceof Error ? error.message : String(error));
+    }
   }, [clientFactory]);
 
   /**

packages/core/src/common/plus-subscription.ts

@@ -1,8 +1,63 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
 import { fetch as undiciFetch } from "undici";
-import { readDeepcodePlusSettings, type DeepcodePlusSettings } from "../settings";
 import type { CreateOpenAIClient, OpenAIClientResult } from "./tool-types";
 
-export const DEEPCODE_PLUS_BASE_URL = "https://deepcode.vegamo.cn/plugin/openai";
+export const DEEPCODE_PLUS_LEGACY_HOST = "https://deepcode.vegamo.cn";
+export const DEEPCODE_PLUS_HOST = "https://www.deepcodeplus.com";
+
+/** Undefined means unconfigured; all explicitly configured values must be valid. */
+export function normalizePlusApiKey(
+  value: unknown,
+  settingsPath = "~/.deepcode-plus/settings.json"
+): string | undefined {
+  if (value === undefined) return undefined;
+  const key = typeof value === "string" ? value.trim() : "";
+  const length = Array.from(key.slice(3)).length;
+  if (!key.startsWith("sk-") || (length !== 24 && length !== 26)) {
+    throw new Error(`Invalid PLUS_API_KEY in ${settingsPath}: expected "sk-" followed by 24 or 26 characters.`);
+  }
+  return key;
+}
+
+export function resolvePlusHost(apiKey?: string): string {
+  const key = normalizePlusApiKey(apiKey);
+  return key && Array.from(key.slice(3)).length === 26 ? DEEPCODE_PLUS_HOST : DEEPCODE_PLUS_LEGACY_HOST;
+}
+
+export function getDeepcodePlusSettingsPath(): string {
+  return path.join(os.homedir(), ".deepcode-plus", "settings.json");
+}
+
+export type SubscriptionPlan = "default" | "on" | "off";
+
+export type DeepcodePlusSettings = {
+  apiKey?: string;
+  subscriptionPlan: SubscriptionPlan;
+};
+
+export function readDeepcodePlusSettings(settingsPath: string = getDeepcodePlusSettingsPath()): DeepcodePlusSettings {
+  let settings: { env?: { PLUS_API_KEY?: unknown }; subscriptionPlan?: unknown } | null;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+  } catch {
+    return { subscriptionPlan: "default" };
+  }
+  return {
+    apiKey: normalizePlusApiKey(settings?.env?.PLUS_API_KEY, settingsPath),
+    subscriptionPlan:
+      settings?.subscriptionPlan === "on" || settings?.subscriptionPlan === "off"
+        ? settings.subscriptionPlan
+        : "default",
+  };
+}
+
+export function readDeepcodePlusApiKey(settingsPath: string = getDeepcodePlusSettingsPath()): string | undefined {
+  return readDeepcodePlusSettings(settingsPath).apiKey;
+}
+
+export const DEEPCODE_PLUS_BASE_URL = `${DEEPCODE_PLUS_LEGACY_HOST}/plugin/openai`;
 export type PlusSubscriptionStatus = "api only" | "full ability" | "unknown";
 export type OpenAIConnection = {
   apiKey?: string;
@@ -21,12 +76,14 @@ export function resolveOpenAIConnection(
   subscriptionPlan: DeepcodePlusSettings["subscriptionPlan"] = "default",
   status: PlusSubscriptionStatus = "unknown"
 ): OpenAIConnection {
+  plusApiKey = normalizePlusApiKey(plusApiKey);
+  const baseURL = `${resolvePlusHost(plusApiKey)}/plugin/openai`;
   const regular = { apiKey: settings.apiKey, baseURL: settings.baseURL, usingPlus: false };
   if (subscriptionPlan === "off") return regular;
   if (subscriptionPlan === "on" && !plusApiKey) {
     return {
       apiKey: undefined,
-      baseURL: DEEPCODE_PLUS_BASE_URL,
+      baseURL,
       usingPlus: false,
       configurationError:
         "PLUS_API_KEY not found. Please configure env.PLUS_API_KEY in ~/.deepcode-plus/settings.json.",
@@ -37,7 +94,7 @@ export function resolveOpenAIConnection(
     (!plusApiKey || status === "api only" || (status === "unknown" && settings.apiKey))
   )
     return regular;
-  return { apiKey: plusApiKey, baseURL: DEEPCODE_PLUS_BASE_URL, usingPlus: true };
+  return { apiKey: plusApiKey, baseURL, usingPlus: true };
 }
 
 type ProbeFetch = (
@@ -57,12 +114,14 @@ export async function checkPlusSubscription(
   timeoutMs = 3000
 ): Promise<PlusSubscriptionStatus> {
   signal?.throwIfAborted();
+  apiKey = normalizePlusApiKey(apiKey)!;
+  const baseURL = `${resolvePlusHost(apiKey)}/plugin/openai`;
   const controller = new AbortController();
   const abort = () => controller.abort(signal?.reason);
   signal?.addEventListener("abort", abort, { once: true });
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const response = await fetcher(`${DEEPCODE_PLUS_BASE_URL}/models`, {
+    const response = await fetcher(`${baseURL}/models`, {
       method: "GET",
       headers: { Authorization: `Bearer ${apiKey}` },
       signal: controller.signal,
@@ -102,7 +161,8 @@ export function withPlusSubscription(
   return Object.assign(() => buildClient(prepared ?? resolve(readSettings(), "unknown")), {
     prepare: async (signal?: AbortSignal) => {
       signal?.throwIfAborted();
-      const plus = readSettings();
+      const settings = readSettings();
+      const plus = { ...settings, apiKey: normalizePlusApiKey(settings.apiKey) };
       const status =
         plus.subscriptionPlan === "default" && plus.apiKey ? await checkSubscription(plus.apiKey, signal) : "unknown";
       signal?.throwIfAborted();

packages/core/src/common/telemetry.ts

@@ -1,9 +1,10 @@
-const DEFAULT_NEW_PROMPT_API_URL = "https://deepcode.vegamo.cn/api/plugin/new";
+import { resolvePlusHost } from "./plus-subscription";
 const DEFAULT_REPORT_TIMEOUT_MS = 3000;
 
 export type NewPromptReportOptions = {
   enabled: boolean;
   machineId?: string;
+  plusApiKey?: string;
   timeoutMs?: number;
 };
 
@@ -16,11 +17,12 @@ export function reportNewPrompt(options: NewPromptReportOptions): void {
     return;
   }
 
+  const url = `${resolvePlusHost(options.plusApiKey)}/api/plugin/new`;
   const timeoutMs = options.timeoutMs ?? DEFAULT_REPORT_TIMEOUT_MS;
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
 
-  void fetch(DEFAULT_NEW_PROMPT_API_URL, {
+  void fetch(url, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",

packages/core/src/session.ts

@@ -2166,8 +2166,8 @@ ${agentInstructions}
   }
 
   private reportNewPrompt(): void {
-    const { machineId, telemetryEnabled } = this.createOpenAIClient();
-    reportNewPrompt({ enabled: telemetryEnabled ?? true, machineId });
+    const { machineId, telemetryEnabled, plusApiKey } = this.createOpenAIClient();
+    reportNewPrompt({ enabled: telemetryEnabled ?? true, machineId, plusApiKey });
   }
 
   interruptActiveSession(): void {

packages/core/src/settings.ts

@@ -775,50 +775,22 @@ export const DEFAULT_BASE_URL = "https://api.deepseek.com";
 // Settings file I/O
 // ---------------------------------------------------------------------------
 
+export {
+  getDeepcodePlusSettingsPath,
+  readDeepcodePlusSettings,
+  readDeepcodePlusApiKey,
+  type SubscriptionPlan,
+  type DeepcodePlusSettings,
+} from "./common/plus-subscription";
+
 export function getUserSettingsPath(): string {
   return path.join(os.homedir(), ".deepcode", "settings.json");
 }
 
-export function getDeepcodePlusSettingsPath(): string {
-  return path.join(os.homedir(), ".deepcode-plus", "settings.json");
-}
-
 export function getProjectSettingsPath(projectRoot: string): string {
   return path.join(projectRoot, ".deepcode", "settings.json");
 }
 
-export type SubscriptionPlan = "default" | "on" | "off";
-
-export type DeepcodePlusSettings = {
-  apiKey?: string;
-  subscriptionPlan: SubscriptionPlan;
-};
-
-export function readDeepcodePlusSettings(settingsPath: string = getDeepcodePlusSettingsPath()): DeepcodePlusSettings {
-  try {
-    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8")) as {
-      env?: { PLUS_API_KEY?: unknown };
-      subscriptionPlan?: unknown;
-    } | null;
-    return {
-      apiKey:
-        typeof settings?.env?.PLUS_API_KEY === "string"
-          ? trimString(settings.env.PLUS_API_KEY) || undefined
-          : undefined,
-      subscriptionPlan:
-        settings?.subscriptionPlan === "on" || settings?.subscriptionPlan === "off"
-          ? settings.subscriptionPlan
-          : "default",
-    };
-  } catch {
-    return { subscriptionPlan: "default" };
-  }
-}
-
-export function readDeepcodePlusApiKey(settingsPath: string = getDeepcodePlusSettingsPath()): string | undefined {
-  return readDeepcodePlusSettings(settingsPath).apiKey;
-}
-
 export function readSettingsFile(settingsPath: string): DeepcodingSettings | null {
   try {
     if (!fs.existsSync(settingsPath)) {

packages/core/src/tests/openai-client.test.ts

@@ -7,10 +7,13 @@ import { Models } from "openai/resources/models";
 import { createOpenAIClientFactory, DEEPCODE_PLUS_BASE_URL, resolveOpenAIConnection } from "../common/openai-client";
 
 test("resolveOpenAIConnection falls back to DeepCode Plus credentials", () => {
-  const resolved = resolveOpenAIConnection({ baseURL: "https://configured.example.com" }, "sk-plus-test");
+  const resolved = resolveOpenAIConnection(
+    { baseURL: "https://configured.example.com" },
+    "sk-aaaaaaaaaaaaaaaaaaaaaaaa"
+  );
 
   assert.deepEqual(resolved, {
-    apiKey: "sk-plus-test",
+    apiKey: "sk-aaaaaaaaaaaaaaaaaaaaaaaa",
     baseURL: DEEPCODE_PLUS_BASE_URL,
     usingPlus: true,
   });
@@ -19,7 +22,7 @@ test("resolveOpenAIConnection falls back to DeepCode Plus credentials", () => {
 test("resolveOpenAIConnection prefers regular credentials", () => {
   const resolved = resolveOpenAIConnection(
     { apiKey: "sk-regular-test", baseURL: "https://configured.example.com" },
-    "sk-plus-test"
+    "sk-aaaaaaaaaaaaaaaaaaaaaaaa"
   );
 
   assert.deepEqual(resolved, {
@@ -49,7 +52,7 @@ test("on mode retains PLUS routing after the existing models warmup fails", asyn
     path.join(home, ".deepcode-plus", "settings.json"),
     JSON.stringify({
       subscriptionPlan: "on",
-      env: { PLUS_API_KEY: "plus-warmup-test" },
+      env: { PLUS_API_KEY: "sk-bbbbbbbbbbbbbbbbbbbbbbbbbb" },
     })
   );
   // Stub the SDK warmup, so no request can reach the real PLUS service.
@@ -61,8 +64,9 @@ test("on mode retains PLUS routing after the existing models warmup fails", asyn
     await new Promise((resolve) => setImmediate(resolve));
     assert.equal(warmup.mock.callCount(), 1);
     assert.equal(first.usingPlus, true);
-    assert.equal(first.apiKey, "plus-warmup-test");
-    assert.equal(first.baseURL, DEEPCODE_PLUS_BASE_URL);
+    assert.equal(first.apiKey, "sk-bbbbbbbbbbbbbbbbbbbbbbbbbb");
+    assert.equal(first.baseURL, "https://www.deepcodeplus.com/plugin/openai");
+    assert.equal(first.client?.baseURL, first.baseURL);
     assert.equal(factory().client, first.client);
     assert.equal(factory().usingPlus, true);
     assert.equal(warmup.mock.callCount(), 1, "cached client should not warm up again");

packages/core/src/tests/plus-api.test.ts

@@ -0,0 +1,103 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  normalizePlusApiKey,
+  resolvePlusHost,
+  checkPlusSubscription,
+  resolveOpenAIConnection,
+  withPlusSubscription,
+} from "../common/plus-subscription";
+import { readDeepcodePlusSettings } from "../settings";
+import { reportNewPrompt } from "../common/telemetry";
+
+const routes = [
+  [undefined, "https://deepcode.vegamo.cn"],
+  [`sk-${"a".repeat(24)}`, "https://deepcode.vegamo.cn"],
+  [`sk-${"b".repeat(26)}`, "https://www.deepcodeplus.com"],
+] as const;
+
+for (const [key, host] of routes) {
+  test(`PLUS routing for ${key?.length ?? "absent"} characters`, async (t) => {
+    assert.equal(resolvePlusHost(key), host);
+    if (key) {
+      assert.equal(normalizePlusApiKey(`  ${key}\n`), key);
+      assert.equal(
+        resolveOpenAIConnection({ baseURL: "https://regular.test" }, key, "on").baseURL,
+        `${host}/plugin/openai`
+      );
+      assert.equal(
+        await checkPlusSubscription(key, undefined, async (url, options) => {
+          assert.equal(url, `${host}/plugin/openai/models`);
+          assert.equal(options.headers.Authorization, `Bearer ${key}`);
+          return { status: 200 };
+        }),
+        "full ability"
+      );
+    }
+    const fetch = t.mock.method(globalThis, "fetch", async (url: string, init: RequestInit) => {
+      assert.equal(url, `${host}/api/plugin/new`);
+      assert.deepEqual(init.headers, { "Content-Type": "application/json", Token: "test-machine" });
+      return new Response("{}");
+    });
+    reportNewPrompt({ enabled: true, machineId: "test-machine", plusApiKey: key });
+    assert.equal(fetch.mock.callCount(), 1);
+    await new Promise((resolve) => setImmediate(resolve));
+  });
+}
+
+test("PLUS suffix is not limited to alphanumeric characters", () => {
+  for (const suffix of ["_".repeat(24), "😀".repeat(26)]) {
+    assert.equal(normalizePlusApiKey(`sk-${suffix}`), `sk-${suffix}`);
+  }
+});
+
+test("configured invalid values fail for every subscription plan without revealing the key", async (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "deepcode-plus-invalid-"));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const file = path.join(dir, "settings.json");
+  t.mock.method(globalThis, "fetch", async () => assert.fail("must not fetch"));
+  for (const plan of ["default", "on", "off"] as const) {
+    for (const value of [
+      "",
+      "   ",
+      null,
+      123,
+      {},
+      [],
+      "secret-invalid-key",
+      `SK-${"a".repeat(24)}`,
+      ...[23, 25, 27].map((length) => `sk-${"a".repeat(length)}`),
+    ]) {
+      fs.writeFileSync(file, JSON.stringify({ subscriptionPlan: plan, env: { PLUS_API_KEY: value } }));
+      assert.throws(
+        () => readDeepcodePlusSettings(file),
+        (error: Error) => {
+          assert.match(error.message, /Invalid PLUS_API_KEY.*settings.json.*24 or 26/);
+          if (typeof value === "string" && value.trim()) assert.ok(!error.message.includes(value));
+          return true;
+        }
+      );
+    }
+    const factory = withPlusSubscription(
+      () => ({ apiKey: "regular", baseURL: "https://regular.test" }),
+      () => assert.fail("must not build a client"),
+      {
+        readSettings: () => ({ apiKey: "invalid", subscriptionPlan: plan }),
+        checkSubscription: async () => assert.fail("must not probe"),
+      }
+    );
+    await assert.rejects(factory.prepare!(), /Invalid PLUS_API_KEY/);
+    assert.throws(() => factory(), /Invalid PLUS_API_KEY/);
+  }
+  await assert.rejects(
+    checkPlusSubscription("invalid", undefined, async () => assert.fail("must not probe")),
+    /Invalid PLUS_API_KEY/
+  );
+  assert.throws(
+    () => reportNewPrompt({ enabled: true, machineId: "test-machine", plusApiKey: "invalid" }),
+    /Invalid PLUS_API_KEY/
+  );
+});