@reconcrap/boss-recommend-mcp 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/skills/boss-recommend-pipeline/SKILL.md

@@ -27,6 +27,7 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 - 当用户请求中出现 “recommend / 推荐页 / boss recommend / recommend page” 语义时，只能走 `boss-recommend-pipeline`
 - 当用户请求中出现 “search / 搜索页 / boss search / search page” 语义时，不能走本技能，必须转交 `boss-recruit-pipeline` 并调用 `run_recruit_pipeline`
 - 不要调用 `boss-recruit-pipeline`，也不要调用 `run_recruit_pipeline`，除非上一条（search/搜索页语义）命中
+- 当 recommend 流程返回任何错误（包括 `JOB_TRIGGER_NOT_FOUND` / `NO_RECOMMEND_IFRAME` / `BOSS_LOGIN_REQUIRED`）时，禁止把 recommend 请求降级到 recruit 流程；必须先修复 recommend 的页面就绪或登录态问题
 
 路由示例（中英文都要兼容）：
 

package/src/index.js

@@ -33,7 +33,7 @@ function createJsonRpcError(id, code, message) {
 function createToolSchema() {
   return {
     name: TOOL_NAME,
-    description: "Boss 推荐页流水线：解析推荐筛选指令、确认岗位/筛选条件/post_action（greet 时确认 max_greet_count），先点击确认岗位，再执行 recommend filter 与 recommend screen 并返回摘要。",
+    description: "Boss 推荐页流水线：解析推荐筛选指令、确认岗位/筛选条件/post_action（greet 时确认 max_greet_count），先点击确认岗位，再执行 recommend filter 与 recommend screen 并返回摘要；也支持通过 instruction 直接发送“暂停 / 停止 / 继续”控制流程状态。",
     inputSchema: {
       type: "object",
       properties: {

package/src/pipeline.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { parseRecommendInstruction } from "./parser.js";
 import {
@@ -379,6 +381,122 @@ function buildChromeSetupGuidance({ debugPort, pageState }) {
   };
 }
 
+const PIPELINE_CONTROL_STATE_RUNNING = "running";
+const PIPELINE_CONTROL_STATE_PAUSED = "paused";
+const PIPELINE_CONTROL_STATE_STOPPED = "stopped";
+const PIPELINE_CONTROL_ACTION_PAUSE = "pause";
+const PIPELINE_CONTROL_ACTION_STOP = "stop";
+const PIPELINE_CONTROL_ACTION_CONTINUE = "continue";
+
+function getStateHome() {
+  return process.env.BOSS_RECOMMEND_HOME
+    ? path.resolve(process.env.BOSS_RECOMMEND_HOME)
+    : path.join(os.homedir(), ".boss-recommend-mcp");
+}
+
+function getPipelineControlStatePath() {
+  return path.join(getStateHome(), "pipeline-control-state.json");
+}
+
+function normalizePipelineControlState(value) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized === PIPELINE_CONTROL_STATE_PAUSED) return PIPELINE_CONTROL_STATE_PAUSED;
+  if (normalized === PIPELINE_CONTROL_STATE_STOPPED) return PIPELINE_CONTROL_STATE_STOPPED;
+  return PIPELINE_CONTROL_STATE_RUNNING;
+}
+
+function readPipelineControlFile() {
+  const filePath = getPipelineControlStatePath();
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function defaultGetPipelineControlState() {
+  const payload = readPipelineControlFile();
+  const state = normalizePipelineControlState(payload?.state);
+  return {
+    state,
+    action: normalizeText(payload?.action || "") || null,
+    updated_at: normalizeText(payload?.updated_at || "") || null
+  };
+}
+
+function defaultSetPipelineControlState(nextState, metadata = {}) {
+  const state = normalizePipelineControlState(nextState);
+  const payload = {
+    state,
+    action: normalizeText(metadata?.action || "") || null,
+    updated_at: new Date().toISOString()
+  };
+  const filePath = getPipelineControlStatePath();
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  } catch {
+    // Keep in-memory response even if persistence fails.
+  }
+  return payload;
+}
+
+function formatPipelineControlState(statePayload) {
+  const normalized = statePayload && typeof statePayload === "object"
+    ? statePayload
+    : {};
+  return {
+    state: normalizePipelineControlState(normalized.state),
+    action: normalizeText(normalized.action || "") || null,
+    updated_at: normalizeText(normalized.updated_at || "") || null
+  };
+}
+
+function normalizeControlInstructionText(instruction) {
+  return normalizeText(instruction).replace(/[。！!？?；;，,]+$/g, "").trim().toLowerCase();
+}
+
+function detectPipelineControlAction(instruction) {
+  const text = normalizeControlInstructionText(instruction);
+  if (!text) return null;
+
+  if (/^(?:请|麻烦|帮我)?\s*(?:先)?\s*(?:暂停|暂停一下|先暂停|pause)\s*$/.test(text)) {
+    return PIPELINE_CONTROL_ACTION_PAUSE;
+  }
+  if (/^(?:请|麻烦|帮我)?\s*(?:先)?\s*(?:停止|终止|结束|stop)\s*$/.test(text)) {
+    return PIPELINE_CONTROL_ACTION_STOP;
+  }
+  if (/^(?:请|麻烦|帮我)?\s*(?:继续|恢复|resume|continue)(?:执行)?\s*$/.test(text)) {
+    return PIPELINE_CONTROL_ACTION_CONTINUE;
+  }
+  return null;
+}
+
+function buildPipelinePausedResponse(controlState) {
+  return {
+    status: "PAUSED",
+    error: {
+      code: "PIPELINE_PAUSED",
+      message: "Recommend 流水线当前处于暂停状态。请先发送“继续”恢复，或发送“停止”结束暂停。",
+      retryable: true
+    },
+    required_user_action: "continue_or_stop_pipeline",
+    control_state: formatPipelineControlState(controlState)
+  };
+}
+
+function buildPipelineControlCommandResponse(status, message, controlState) {
+  return {
+    status,
+    message,
+    control_state: formatPipelineControlState(controlState)
+  };
+}
+
 const defaultDependencies = {
   attemptPipelineAutoRepair,
   parseRecommendInstruction,
@@ -386,7 +504,9 @@ const defaultDependencies = {
   listRecommendJobs,
   runPipelinePreflight,
   runRecommendSearchCli,
-  runRecommendScreenCli
+  runRecommendScreenCli,
+  getPipelineControlState: defaultGetPipelineControlState,
+  setPipelineControlState: defaultSetPipelineControlState
 };
 
 export async function runRecommendPipeline(
@@ -402,10 +522,82 @@ export async function runRecommendPipeline(
     listRecommendJobs: listJobs,
     runPipelinePreflight: runPreflight,
     runRecommendSearchCli: searchCli,
-    runRecommendScreenCli: screenCli
+    runRecommendScreenCli: screenCli,
+    getPipelineControlState: getControlState,
+    setPipelineControlState: setControlState
   } = resolvedDependencies;
-  const startedAt = Date.now();
-  const parsed = parseInstruction({ instruction, confirmation, overrides });
+
+  const controlAction = detectPipelineControlAction(instruction);
+  const currentControlState = formatPipelineControlState(
+    typeof getControlState === "function"
+      ? getControlState(workspaceRoot)
+      : defaultGetPipelineControlState()
+  );
+
+  if (controlAction === PIPELINE_CONTROL_ACTION_PAUSE) {
+    const pausedState = formatPipelineControlState(
+      typeof setControlState === "function"
+        ? setControlState(PIPELINE_CONTROL_STATE_PAUSED, { action: PIPELINE_CONTROL_ACTION_PAUSE })
+        : defaultSetPipelineControlState(PIPELINE_CONTROL_STATE_PAUSED, { action: PIPELINE_CONTROL_ACTION_PAUSE })
+    );
+    return buildPipelineControlCommandResponse(
+      "PAUSED",
+      "已暂停 Recommend 流水线。后续如需恢复请发送“继续”，如需终止暂停请发送“停止”。",
+      pausedState
+    );
+  }
+
+  if (controlAction === PIPELINE_CONTROL_ACTION_STOP) {
+    const stoppedState = formatPipelineControlState(
+      typeof setControlState === "function"
+        ? setControlState(PIPELINE_CONTROL_STATE_STOPPED, { action: PIPELINE_CONTROL_ACTION_STOP })
+        : defaultSetPipelineControlState(PIPELINE_CONTROL_STATE_STOPPED, { action: PIPELINE_CONTROL_ACTION_STOP })
+    );
+    return buildPipelineControlCommandResponse(
+      "STOPPED",
+      "已停止 Recommend 流水线。后续可直接发送新的筛选指令重新开始。",
+      stoppedState
+    );
+  }
+
+  if (controlAction === PIPELINE_CONTROL_ACTION_CONTINUE) {
+    if (currentControlState.state !== PIPELINE_CONTROL_STATE_PAUSED) {
+      return buildFailedResponse(
+        "PIPELINE_CONTINUE_REQUIRES_PAUSED",
+        "当前流程未处于暂停状态，无法执行“继续”。请先发送“暂停”，或直接发送新的筛选指令。",
+        {
+          required_user_action: "pause_before_continue",
+          control_state: currentControlState
+        }
+      );
+    }
+    const resumedState = formatPipelineControlState(
+      typeof setControlState === "function"
+        ? setControlState(PIPELINE_CONTROL_STATE_RUNNING, { action: PIPELINE_CONTROL_ACTION_CONTINUE })
+        : defaultSetPipelineControlState(PIPELINE_CONTROL_STATE_RUNNING, { action: PIPELINE_CONTROL_ACTION_CONTINUE })
+    );
+    return buildPipelineControlCommandResponse(
+      "RESUMED",
+      "已恢复 Recommend 流水线。请继续发送筛选指令，我会按确认流程继续执行。",
+      resumedState
+    );
+  }
+
+  if (currentControlState.state === PIPELINE_CONTROL_STATE_PAUSED) {
+    return buildPipelinePausedResponse(currentControlState);
+  }
+
+  if (currentControlState.state !== PIPELINE_CONTROL_STATE_RUNNING) {
+    const nextActiveState = formatPipelineControlState(
+      typeof setControlState === "function"
+        ? setControlState(PIPELINE_CONTROL_STATE_RUNNING, { action: "run" })
+        : defaultSetPipelineControlState(PIPELINE_CONTROL_STATE_RUNNING, { action: "run" })
+    );
+    Object.assign(currentControlState, nextActiveState);
+  }
+
+  const startedAt = Date.now();
+  const parsed = parseInstruction({ instruction, confirmation, overrides });
 
   if (parsed.missing_fields.length > 0) {
     return buildNeedInputResponse(parsed);
@@ -534,6 +726,54 @@ export async function runRecommendPipeline(
     port: preflight.debug_port
   });
   if (!jobListResult.ok) {
+    const jobListErrorCode = String(jobListResult.error?.code || "");
+    const jobListErrorMessage = String(jobListResult.error?.message || "");
+    const pageReadinessFailure = (
+      jobListErrorCode === "JOB_TRIGGER_NOT_FOUND"
+      || jobListErrorCode === "NO_RECOMMEND_IFRAME"
+      || jobListErrorCode === "LOGIN_REQUIRED"
+      || jobListErrorMessage.includes("JOB_TRIGGER_NOT_FOUND")
+      || jobListErrorMessage.includes("NO_RECOMMEND_IFRAME")
+      || jobListErrorMessage.includes("LOGIN_REQUIRED")
+    );
+    if (pageReadinessFailure) {
+      const recheck = await ensureRecommendPageReady(workspaceRoot, {
+        port: preflight.debug_port
+      });
+      const loginRelated = new Set(["LOGIN_REQUIRED", "LOGIN_REQUIRED_AFTER_REDIRECT"]);
+      const connectivityRelated = new Set(["DEBUG_PORT_UNREACHABLE"]);
+      const guidance = buildChromeSetupGuidance({
+        debugPort: preflight.debug_port,
+        pageState: recheck.page_state
+      });
+      if (!recheck.ok || loginRelated.has(recheck.state) || connectivityRelated.has(recheck.state)) {
+        return buildFailedResponse(
+          connectivityRelated.has(recheck.state)
+            ? "BOSS_CHROME_NOT_CONNECTED"
+            : loginRelated.has(recheck.state)
+              ? "BOSS_LOGIN_REQUIRED"
+              : "BOSS_RECOMMEND_PAGE_NOT_READY",
+          loginRelated.has(recheck.state)
+            ? `检测到当前 Boss 处于未登录状态，请先登录后再继续。登录页：https://www.zhipin.com/web/user/?ka=bticket`
+            : connectivityRelated.has(recheck.state)
+              ? `读取岗位列表前需要先连接到端口 ${preflight.debug_port} 的 Chrome 远程调试实例。`
+              : `读取岗位列表前，请先在端口 ${preflight.debug_port} 的 Chrome 停留在 Boss recommend 页面。`,
+          {
+            search_params: parsed.searchParams,
+            screen_params: parsed.screenParams,
+            required_user_action: "prepare_boss_recommend_page",
+            guidance,
+            diagnostics: {
+              debug_port: preflight.debug_port,
+              page_state: recheck.page_state,
+              stdout: jobListResult.stdout?.slice(-1000),
+              stderr: jobListResult.stderr?.slice(-1000),
+              result: jobListResult.structured || null
+            }
+          }
+        );
+      }
+    }
     return buildFailedResponse(
       jobListResult.error?.code || "RECOMMEND_JOB_LIST_FAILED",
       jobListResult.error?.message || "读取推荐岗位列表失败，无法开始筛选。",

package/src/test-pipeline.js

@@ -78,6 +78,152 @@ function createParsed(overrides = {}) {
   };
 }
 
+function createControlStateStore(initialState = "running") {
+  let state = {
+    state: initialState,
+    action: null,
+    updated_at: null
+  };
+  return {
+    getPipelineControlState: () => ({ ...state }),
+    setPipelineControlState: (nextState, metadata = {}) => {
+      state = {
+        state: nextState,
+        action: metadata.action || null,
+        updated_at: "2026-01-01T00:00:00.000Z"
+      };
+      return { ...state };
+    },
+    snapshot: () => ({ ...state })
+  };
+}
+
+async function testPauseCommandShouldPausePipeline() {
+  const controlStore = createControlStateStore("running");
+  let parseCalled = false;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "暂停",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      getPipelineControlState: controlStore.getPipelineControlState,
+      setPipelineControlState: controlStore.setPipelineControlState,
+      parseRecommendInstruction: () => {
+        parseCalled = true;
+        return createParsed();
+      }
+    }
+  );
+
+  assert.equal(result.status, "PAUSED");
+  assert.equal(result.control_state.state, "paused");
+  assert.equal(parseCalled, false);
+}
+
+async function testContinueCommandRequiresPausedState() {
+  const controlStore = createControlStateStore("running");
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "继续",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      getPipelineControlState: controlStore.getPipelineControlState,
+      setPipelineControlState: controlStore.setPipelineControlState
+    }
+  );
+
+  assert.equal(result.status, "FAILED");
+  assert.equal(result.error.code, "PIPELINE_CONTINUE_REQUIRES_PAUSED");
+}
+
+async function testContinueCommandCanResumeFromPausedState() {
+  const controlStore = createControlStateStore("running");
+  await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "暂停",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      getPipelineControlState: controlStore.getPipelineControlState,
+      setPipelineControlState: controlStore.setPipelineControlState
+    }
+  );
+
+  const resumed = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "继续",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      getPipelineControlState: controlStore.getPipelineControlState,
+      setPipelineControlState: controlStore.setPipelineControlState
+    }
+  );
+
+  assert.equal(resumed.status, "RESUMED");
+  assert.equal(resumed.control_state.state, "running");
+}
+
+async function testPipelineShouldBlockWhenPaused() {
+  const controlStore = createControlStateStore("paused");
+  let parseCalled = false;
+  let preflightCalled = false;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "推荐页筛选985男生",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      getPipelineControlState: controlStore.getPipelineControlState,
+      setPipelineControlState: controlStore.setPipelineControlState,
+      parseRecommendInstruction: () => {
+        parseCalled = true;
+        return createParsed();
+      },
+      runPipelinePreflight: () => {
+        preflightCalled = true;
+        return { ok: true, checks: [], debug_port: 9222 };
+      }
+    }
+  );
+
+  assert.equal(result.status, "PAUSED");
+  assert.equal(result.error.code, "PIPELINE_PAUSED");
+  assert.equal(parseCalled, false);
+  assert.equal(preflightCalled, false);
+}
+
+async function testStopCommandShouldExitPausedState() {
+  const controlStore = createControlStateStore("paused");
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "停止",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      getPipelineControlState: controlStore.getPipelineControlState,
+      setPipelineControlState: controlStore.setPipelineControlState
+    }
+  );
+
+  assert.equal(result.status, "STOPPED");
+  assert.equal(result.control_state.state, "stopped");
+}
+
 async function testNeedConfirmationGate() {
   let preflightCalled = false;
   const result = await runRecommendPipeline(
@@ -344,6 +490,50 @@ async function testSearchNoIframeWithLoginShouldReturnLoginRequired() {
   assert.equal(result.guidance.agent_prompt.includes("https://www.zhipin.com/web/user/?ka=bticket"), true);
 }
 
+async function testJobTriggerNotFoundShouldMapToLoginRequiredWhenRecheckShowsLogin() {
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({
+        ok: false,
+        debug_port: 9222,
+        state: "LOGIN_REQUIRED",
+        page_state: {
+          state: "LOGIN_REQUIRED",
+          expected_url: "https://www.zhipin.com/web/chat/recommend",
+          current_url: "https://www.zhipin.com/web/user/?ka=bticket",
+          login_url: "https://www.zhipin.com/web/user/?ka=bticket"
+        }
+      }),
+      listRecommendJobs: async () => ({
+        ok: false,
+        stdout: "",
+        stderr: "",
+        structured: null,
+        jobs: [],
+        error: {
+          code: "JOB_TRIGGER_NOT_FOUND",
+          message: "JOB_TRIGGER_NOT_FOUND"
+        }
+      }),
+      runRecommendSearchCli: async () => ({ ok: true, summary: {} }),
+      runRecommendScreenCli: async () => ({ ok: true, summary: {} })
+    }
+  );
+
+  assert.equal(result.status, "FAILED");
+  assert.equal(result.error.code, "BOSS_LOGIN_REQUIRED");
+  assert.equal(result.required_user_action, "prepare_boss_recommend_page");
+  assert.equal(result.guidance.agent_prompt.includes("https://www.zhipin.com/web/user/?ka=bticket"), true);
+}
+
 async function testNeedJobConfirmationGate() {
   const result = await runRecommendPipeline(
     {
@@ -711,6 +901,11 @@ async function testScreenConfigRecoveryStepShouldBeFirst() {
 }
 
 async function main() {
+  await testPauseCommandShouldPausePipeline();
+  await testContinueCommandRequiresPausedState();
+  await testContinueCommandCanResumeFromPausedState();
+  await testPipelineShouldBlockWhenPaused();
+  await testStopCommandShouldExitPausedState();
   await testNeedConfirmationGate();
   await testNeedSchoolTagConfirmationGate();
   await testNeedTargetCountConfirmationGate();
@@ -721,6 +916,7 @@ async function main() {
   await testCompletedPipeline();
   await testSearchFailure();
   await testSearchNoIframeWithLoginShouldReturnLoginRequired();
+  await testJobTriggerNotFoundShouldMapToLoginRequiredWhenRecheckShowsLogin();
   await testLoginRequiredShouldReturnGuidance();
   await testDebugPortUnreachableShouldReturnConnectionCode();
   await testPreflightRecoveryPlanOrder();

package/vendor/boss-recommend-search-cli/src/cli.js

@@ -10,10 +10,10 @@ const BOSS_LOGIN_URL = "https://www.zhipin.com/web/user/?ka=bticket";
 const BOSS_LOGIN_URL_PATTERN = /(?:zhipin\.com\/web\/user(?:\/|\?|$)|passport\.zhipin\.com)/i;
 const BOSS_LOGIN_TITLE_PATTERN = /登录|signin|扫码登录|BOSS直聘登录/i;
 const SCHOOL_TAG_OPTIONS = ["不限", "985", "211", "双一流院校", "留学", "国内外名校", "公办本科"];
-const DEGREE_OPTIONS = ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"];
-const DEGREE_ORDER = ["初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"];
-const GENDER_OPTIONS = ["不限", "男", "女"];
-const RECENT_NOT_VIEW_OPTIONS = ["不限", "近14天没有"];
+const DEGREE_OPTIONS = ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"];
+const DEGREE_ORDER = ["初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"];
+const GENDER_OPTIONS = ["不限", "男", "女"];
+const RECENT_NOT_VIEW_OPTIONS = ["不限", "近14天没有"];
 
 function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
@@ -107,7 +107,7 @@ function expandDegreeAtOrAbove(value) {
   return DEGREE_ORDER.slice(index);
 }
 
-function parseDegreeSelection(raw) {
+function parseDegreeSelection(raw) {
   const text = normalizeText(raw);
   if (!text) return null;
   if (text === "不限") return ["不限"];
@@ -132,9 +132,9 @@ function parseDegreeSelection(raw) {
     }
   }
 
-  const normalized = sortDegreeSelection(selected);
-  return normalized.length ? normalized : null;
-}
+  const normalized = sortDegreeSelection(selected);
+  return normalized.length ? normalized : null;
+}
 
 function parseArgs(argv) {
   const args = {
@@ -296,14 +296,14 @@ function generateBezierPath(start, end, steps = 18) {
   return path;
 }
 
-class RecommendSearchCli {
-  constructor(args) {
-    this.args = args;
-    this.client = null;
-    this.Runtime = null;
-    this.Input = null;
-    this.target = null;
-  }
+class RecommendSearchCli {
+  constructor(args) {
+    this.args = args;
+    this.client = null;
+    this.Runtime = null;
+    this.Input = null;
+    this.target = null;
+  }
 
   async connect() {
     const targets = await CDP.List({ port: this.args.port });
@@ -792,7 +792,7 @@ class RecommendSearchCli {
     })()`);
   }
 
-  async openFilterPanel() {
+  async openFilterPanel() {
     if (await this.isFilterPanelVisible()) return;
     let lastError = 'FILTER_PANEL_UNAVAILABLE';
     for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -821,8 +821,8 @@ class RecommendSearchCli {
         lastError = fallback?.error || lastError;
       }
     }
-    throw new Error(lastError === 'FILTER_TRIGGER_NOT_FOUND' ? lastError : 'FILTER_PANEL_UNAVAILABLE');
-  }
+    throw new Error(lastError === 'FILTER_TRIGGER_NOT_FOUND' ? lastError : 'FILTER_PANEL_UNAVAILABLE');
+  }
 
   async closeFilterPanel() {
     if (!(await this.isFilterPanelVisible())) {
@@ -1480,10 +1480,10 @@ class RecommendSearchCli {
     if (!Array.isArray(this.args.schoolTag) || this.args.schoolTag.length === 0) {
       throw new Error("INVALID_SCHOOL_TAG_INPUT");
     }
-    if (!Array.isArray(this.args.degree) || this.args.degree.length === 0) {
-      throw new Error("INVALID_DEGREE_INPUT");
-    }
-
+    if (!Array.isArray(this.args.degree) || this.args.degree.length === 0) {
+      throw new Error("INVALID_DEGREE_INPUT");
+    }
+
     await this.connect();
     try {
       const frameState = await this.getFrameState();