@reconcrap/boss-recommend-mcp 1.3.39 → 2.0.0

package/vendor/boss-chat-cli/src/mcp/server.js

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-import process from 'node:process';
-
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import * as z from 'zod/v4';
-
-import { runCliJsonCommand } from './tool-runtime.js';
-
-const SERVER_VERSION = process.env.BOSS_CHAT_MCP_VERSION || '1.1.0';
-
-function toToolResult(payload, isError = false) {
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(payload, null, 2),
-      },
-    ],
-    structuredContent: payload,
-    isError,
-  };
-}
-
-async function executeCliCommand(command, input) {
-  const result = await runCliJsonCommand(command, input);
-  const payload = {
-    ...result.payload,
-    _meta: {
-      command: result.command,
-      args: result.args,
-      exitCode: result.exitCode,
-      stderr: String(result.stderr || '').trim() || undefined,
-    },
-  };
-
-  if (!payload._meta.stderr) {
-    delete payload._meta.stderr;
-  }
-  return toToolResult(payload, !result.ok);
-}
-
-function registerTools(server) {
-  server.registerTool(
-    'health_check',
-    {
-      description: '检查 MCP 服务与 CLI 适配层是否可用。',
-      inputSchema: {},
-    },
-    async () =>
-      toToolResult({
-        status: 'OK',
-        server: 'boss-chat-mcp',
-        version: SERVER_VERSION,
-        supportedAgents: ['openclaw', 'codex', 'trae-cn'],
-      }),
-  );
-
-  server.registerTool(
-    'start_run',
-    {
-      description: '异步启动一次 Boss chat 任务并返回 run_id。',
-      inputSchema: {
-        profile: z.string().optional().describe('Profile 名称，默认 default'),
-        dryRun: z.boolean().optional().describe('true 时不发出索要简历动作'),
-        noState: z.boolean().optional().describe('true 时不记录已处理状态'),
-        job: z.string().describe('岗位，支持岗位名/编号/value'),
-        startFrom: z
-          .enum(['unread', 'all'])
-          .optional()
-          .describe('从未读或全部聊天列表开始'),
-        criteria: z.string().describe('筛选标准'),
-        targetCount: z.number().int().positive().optional().describe('本次处理上限'),
-        baseUrl: z.string().optional().describe('覆盖 LLM baseUrl'),
-        apiKey: z.string().optional().describe('覆盖 LLM apiKey'),
-        model: z.string().optional().describe('覆盖 LLM 模型'),
-        thinkingLevel: z.string().optional().describe('覆盖 LLM thinking/reasoning 级别：off/low/medium/high/current'),
-        port: z.number().int().positive().optional().describe('Chrome 调试端口'),
-        safePacing: z.boolean().optional().describe('是否启用安全节奏控制'),
-        batchRestEnabled: z.boolean().optional().describe('是否启用批次休息'),
-      },
-    },
-    async (input) => executeCliCommand('start-run', input),
-  );
-
-  server.registerTool(
-    'get_run',
-    {
-      description: '查询 run_id 对应任务的当前状态。',
-      inputSchema: {
-        runId: z.string().min(1).describe('start_run 返回的 run_id'),
-        profile: z.string().optional().describe('可选，默认 default'),
-      },
-    },
-    async (input) => executeCliCommand('get-run', input),
-  );
-
-  server.registerTool(
-    'pause_run',
-    {
-      description: '暂停运行中的任务。',
-      inputSchema: {
-        runId: z.string().min(1).describe('start_run 返回的 run_id'),
-        profile: z.string().optional().describe('可选，默认 default'),
-      },
-    },
-    async (input) => executeCliCommand('pause-run', input),
-  );
-
-  server.registerTool(
-    'resume_run',
-    {
-      description: '继续已暂停任务。',
-      inputSchema: {
-        runId: z.string().min(1).describe('start_run 返回的 run_id'),
-        profile: z.string().optional().describe('可选，默认 default'),
-      },
-    },
-    async (input) => executeCliCommand('resume-run', input),
-  );
-
-  server.registerTool(
-    'cancel_run',
-    {
-      description: '取消运行中的任务（在安全点停止）。',
-      inputSchema: {
-        runId: z.string().min(1).describe('start_run 返回的 run_id'),
-        profile: z.string().optional().describe('可选，默认 default'),
-      },
-    },
-    async (input) => executeCliCommand('cancel-run', input),
-  );
-}
-
-async function main() {
-  const server = new McpServer({
-    name: 'boss-chat-mcp',
-    version: SERVER_VERSION,
-  });
-  registerTools(server);
-
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-main().catch((error) => {
-  console.error('[boss-chat-mcp] server failed:', error?.stack || error?.message || String(error));
-  process.exit(1);
-});

package/vendor/boss-chat-cli/src/mcp/tool-runtime.js

@@ -1,193 +0,0 @@
-import { spawn } from 'node:child_process';
-import process from 'node:process';
-import { fileURLToPath } from 'node:url';
-
-const CLI_PATH = fileURLToPath(new URL('../cli.js', import.meta.url));
-
-function pushValueArg(args, name, value) {
-  if (value === undefined || value === null || value === '') {
-    return;
-  }
-  args.push(`--${name}`, String(value));
-}
-
-function pushBooleanArg(args, name, value) {
-  if (value === true) {
-    args.push(`--${name}`);
-  }
-}
-
-function parseJsonFromStdout(stdout) {
-  const trimmed = String(stdout || '').trim();
-  if (!trimmed) return null;
-
-  try {
-    return JSON.parse(trimmed);
-  } catch {}
-
-  const lines = trimmed
-    .split(/\r?\n/g)
-    .map((line) => line.trim())
-    .filter(Boolean);
-  for (let index = lines.length - 1; index >= 0; index -= 1) {
-    try {
-      return JSON.parse(lines[index]);
-    } catch {}
-  }
-  return null;
-}
-
-function normalizeStartFrom(input) {
-  const value = String(input || '').trim().toLowerCase();
-  if (value === 'all') return 'all';
-  return 'unread';
-}
-
-function normalizePositiveInt(input) {
-  if (input === undefined || input === null || input === '') return null;
-  const value = Number.parseInt(String(input), 10);
-  if (!Number.isFinite(value) || value <= 0) return null;
-  return value;
-}
-
-export function buildCliArgs(command, input = {}) {
-  const args = [String(command), '--json'];
-  pushValueArg(args, 'profile', input.profile || 'default');
-  pushBooleanArg(args, 'dry-run', input.dryRun);
-  pushBooleanArg(args, 'no-state', input.noState);
-
-  switch (command) {
-    case 'start-run':
-    case 'run': {
-      pushValueArg(args, 'job', input.job);
-      pushValueArg(args, 'start-from', normalizeStartFrom(input.startFrom));
-      pushValueArg(args, 'criteria', input.criteria);
-
-      const targetCount = normalizePositiveInt(input.targetCount);
-      if (targetCount) {
-        pushValueArg(args, 'targetCount', targetCount);
-      }
-
-      pushValueArg(args, 'baseurl', input.baseUrl);
-      pushValueArg(args, 'apikey', input.apiKey);
-      pushValueArg(args, 'model', input.model);
-      pushValueArg(args, 'thinking-level', input.thinkingLevel || input.llmThinkingLevel || input.reasoningEffort);
-
-      const port = normalizePositiveInt(input.port);
-      if (port) {
-        pushValueArg(args, 'port', port);
-      }
-
-      if (typeof input.safePacing === 'boolean') {
-        pushValueArg(args, 'safe-pacing', String(input.safePacing));
-      }
-      if (typeof input.batchRestEnabled === 'boolean') {
-        pushValueArg(args, 'batch-rest', String(input.batchRestEnabled));
-      }
-      break;
-    }
-    case 'get-run':
-    case 'pause-run':
-    case 'resume-run':
-    case 'cancel-run':
-      pushValueArg(args, 'run-id', input.runId);
-      break;
-    default:
-      break;
-  }
-
-  return args;
-}
-
-export async function runCliJsonCommand(command, input = {}) {
-  const cliArgs = buildCliArgs(command, input);
-  const cwd = String(input.cwd || process.cwd());
-
-  return new Promise((resolve) => {
-    const child = spawn(process.execPath, [CLI_PATH, ...cliArgs], {
-      cwd,
-      env: process.env,
-      windowsHide: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let stdout = '';
-    let stderr = '';
-    child.stdout.on('data', (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on('data', (chunk) => {
-      stderr += String(chunk);
-    });
-
-    child.on('error', (error) => {
-      resolve({
-        ok: false,
-        exitCode: -1,
-        command,
-        args: cliArgs,
-        stdout,
-        stderr,
-        payload: {
-          status: 'FAILED',
-          error: {
-            code: 'CLI_SPAWN_FAILED',
-            message: error?.message || '无法启动 boss-chat CLI',
-            retryable: true,
-          },
-        },
-      });
-    });
-
-    child.on('close', (code) => {
-      const exitCode = Number.isInteger(code) ? code : 1;
-      const parsed = parseJsonFromStdout(stdout);
-
-      if (parsed && typeof parsed === 'object') {
-        resolve({
-          ok: exitCode === 0 && parsed.status !== 'FAILED',
-          exitCode,
-          command,
-          args: cliArgs,
-          stdout,
-          stderr,
-          payload: parsed,
-        });
-        return;
-      }
-
-      if (exitCode === 0) {
-        resolve({
-          ok: true,
-          exitCode,
-          command,
-          args: cliArgs,
-          stdout,
-          stderr,
-          payload: {
-            status: 'OK',
-            message: String(stdout || '').trim() || `${command} 执行成功`,
-          },
-        });
-        return;
-      }
-
-      resolve({
-        ok: false,
-        exitCode,
-        command,
-        args: cliArgs,
-        stdout,
-        stderr,
-        payload: {
-          status: 'FAILED',
-          error: {
-            code: 'CLI_EXECUTION_FAILED',
-            message: String(stderr || stdout || '').trim() || `${command} 执行失败`,
-            retryable: true,
-          },
-        },
-      });
-    });
-  });
-}

package/vendor/boss-chat-cli/src/runtime/async-run-state.js

@@ -1,260 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-
-export const RUN_MODE_ASYNC = 'async';
-
-export const RUN_STATE_QUEUED = 'queued';
-export const RUN_STATE_RUNNING = 'running';
-export const RUN_STATE_PAUSED = 'paused';
-export const RUN_STATE_COMPLETED = 'completed';
-export const RUN_STATE_FAILED = 'failed';
-export const RUN_STATE_CANCELED = 'canceled';
-
-const TERMINAL_RUN_STATES = new Set([
-  RUN_STATE_COMPLETED,
-  RUN_STATE_FAILED,
-  RUN_STATE_CANCELED,
-]);
-
-function nowIso() {
-  return new Date().toISOString();
-}
-
-function normalizeRunId(runId) {
-  const normalized = String(runId || '').trim();
-  if (!normalized || normalized.includes('/') || normalized.includes('\\')) {
-    throw new Error('Invalid run_id');
-  }
-  return normalized;
-}
-
-function ensureRunsDir(baseDir) {
-  const runsDir = path.join(baseDir, 'runs');
-  fs.mkdirSync(runsDir, { recursive: true });
-  return runsDir;
-}
-
-export function createRunId() {
-  if (typeof crypto.randomUUID === 'function') {
-    return crypto.randomUUID();
-  }
-  return crypto.randomBytes(16).toString('hex');
-}
-
-export function getRunStatePath(baseDir, runId) {
-  const normalizedRunId = normalizeRunId(runId);
-  return path.join(ensureRunsDir(baseDir), `${normalizedRunId}.json`);
-}
-
-export function getRunEventsPath(baseDir, runId) {
-  const normalizedRunId = normalizeRunId(runId);
-  return path.join(ensureRunsDir(baseDir), `${normalizedRunId}.events.jsonl`);
-}
-
-function writeJsonAtomic(filePath, payload) {
-  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  fs.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
-  fs.renameSync(tmpPath, filePath);
-}
-
-function clonePlain(value, fallback = null) {
-  try {
-    return JSON.parse(JSON.stringify(value));
-  } catch {
-    return fallback;
-  }
-}
-
-function normalizeProgress(progress = {}) {
-  return {
-    inspected:
-      Number.isInteger(progress.inspected) && progress.inspected >= 0
-        ? progress.inspected
-        : 0,
-    passed:
-      Number.isInteger(progress.passed) && progress.passed >= 0 ? progress.passed : 0,
-    requested:
-      Number.isInteger(progress.requested) && progress.requested >= 0
-        ? progress.requested
-        : 0,
-    skipped:
-      Number.isInteger(progress.skipped) && progress.skipped >= 0 ? progress.skipped : 0,
-    errors:
-      Number.isInteger(progress.errors) && progress.errors >= 0 ? progress.errors : 0,
-  };
-}
-
-function normalizeControl(control = {}) {
-  return {
-    pauseRequested: control?.pauseRequested === true,
-    cancelRequested: control?.cancelRequested === true,
-  };
-}
-
-function normalizeState(state) {
-  const normalized = String(state || '').trim().toLowerCase();
-  if (
-    [
-      RUN_STATE_QUEUED,
-      RUN_STATE_RUNNING,
-      RUN_STATE_PAUSED,
-      RUN_STATE_COMPLETED,
-      RUN_STATE_FAILED,
-      RUN_STATE_CANCELED,
-    ].includes(normalized)
-  ) {
-    return normalized;
-  }
-  return RUN_STATE_QUEUED;
-}
-
-export function createRunStateSnapshot({
-  runId,
-  pid = null,
-  request = null,
-  state = RUN_STATE_QUEUED,
-  stage = 'preflight',
-  lastMessage = '任务已创建，等待执行。',
-} = {}) {
-  const createdAt = nowIso();
-  return {
-    runId: normalizeRunId(runId),
-    mode: RUN_MODE_ASYNC,
-    state: normalizeState(state),
-    stage: String(stage || 'preflight'),
-    createdAt,
-    updatedAt: createdAt,
-    heartbeatAt: createdAt,
-    pid: Number.isInteger(pid) && pid > 0 ? pid : null,
-    lastMessage: String(lastMessage || ''),
-    progress: normalizeProgress(),
-    control: normalizeControl(),
-    request: clonePlain(request, null),
-    error: null,
-    result: null,
-  };
-}
-
-export function writeRunState(baseDir, snapshot) {
-  const normalizedSnapshot = {
-    ...snapshot,
-    runId: normalizeRunId(snapshot?.runId),
-    mode: RUN_MODE_ASYNC,
-    state: normalizeState(snapshot?.state),
-    stage: String(snapshot?.stage || 'preflight'),
-    createdAt: String(snapshot?.createdAt || nowIso()),
-    updatedAt: String(snapshot?.updatedAt || nowIso()),
-    heartbeatAt: String(snapshot?.heartbeatAt || nowIso()),
-    pid:
-      Number.isInteger(snapshot?.pid) && snapshot.pid > 0
-        ? snapshot.pid
-        : null,
-    lastMessage: String(snapshot?.lastMessage || ''),
-    progress: normalizeProgress(snapshot?.progress || {}),
-    control: normalizeControl(snapshot?.control || {}),
-    request: clonePlain(snapshot?.request, null),
-    error: Object.prototype.hasOwnProperty.call(snapshot || {}, 'error')
-      ? snapshot.error
-      : null,
-    result: Object.prototype.hasOwnProperty.call(snapshot || {}, 'result')
-      ? snapshot.result
-      : null,
-  };
-  writeJsonAtomic(getRunStatePath(baseDir, normalizedSnapshot.runId), normalizedSnapshot);
-  return normalizedSnapshot;
-}
-
-export function readRunState(baseDir, runId) {
-  try {
-    const raw = fs.readFileSync(getRunStatePath(baseDir, runId), 'utf8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-      return null;
-    }
-    return {
-      ...parsed,
-      runId: normalizeRunId(parsed.runId),
-      state: normalizeState(parsed.state),
-      progress: normalizeProgress(parsed.progress || {}),
-      control: normalizeControl(parsed.control || {}),
-      pid: Number.isInteger(parsed.pid) && parsed.pid > 0 ? parsed.pid : null,
-      mode: RUN_MODE_ASYNC,
-      stage: String(parsed.stage || 'preflight'),
-      lastMessage: String(parsed.lastMessage || ''),
-      createdAt: String(parsed.createdAt || ''),
-      updatedAt: String(parsed.updatedAt || ''),
-      heartbeatAt: String(parsed.heartbeatAt || ''),
-    };
-  } catch (error) {
-    if (error && error.code === 'ENOENT') {
-      return null;
-    }
-    throw error;
-  }
-}
-
-export function updateRunState(baseDir, runId, updater) {
-  const current = readRunState(baseDir, runId);
-  if (!current) return null;
-
-  const patch =
-    typeof updater === 'function' ? updater(clonePlain(current, current)) : updater;
-  if (!patch || typeof patch !== 'object') {
-    return current;
-  }
-
-  const now = nowIso();
-  const next = {
-    ...current,
-    ...patch,
-    runId: current.runId,
-    mode: RUN_MODE_ASYNC,
-    state: normalizeState(patch.state ?? current.state),
-    stage: String(patch.stage ?? current.stage ?? 'preflight'),
-    progress: normalizeProgress({
-      ...current.progress,
-      ...(patch.progress || {}),
-    }),
-    control: normalizeControl({
-      ...current.control,
-      ...(patch.control || {}),
-    }),
-    lastMessage: Object.prototype.hasOwnProperty.call(patch, 'lastMessage')
-      ? String(patch.lastMessage || '')
-      : current.lastMessage,
-    pid: Object.prototype.hasOwnProperty.call(patch, 'pid')
-      ? Number.isInteger(patch.pid) && patch.pid > 0
-        ? patch.pid
-        : null
-      : current.pid,
-    updatedAt: now,
-    heartbeatAt: Object.prototype.hasOwnProperty.call(patch, 'heartbeatAt')
-      ? String(patch.heartbeatAt || now)
-      : current.heartbeatAt || now,
-    error: Object.prototype.hasOwnProperty.call(patch, 'error')
-      ? patch.error
-      : current.error,
-    result: Object.prototype.hasOwnProperty.call(patch, 'result')
-      ? patch.result
-      : current.result,
-  };
-
-  writeRunState(baseDir, next);
-  return next;
-}
-
-export function appendRunEvent(baseDir, runId, event = {}) {
-  const filePath = getRunEventsPath(baseDir, runId);
-  const payload = {
-    timestamp: nowIso(),
-    runId: normalizeRunId(runId),
-    ...clonePlain(event, {}),
-  };
-  fs.appendFileSync(filePath, `${JSON.stringify(payload)}\n`, 'utf8');
-  return payload;
-}
-
-export function isTerminalRunState(state) {
-  return TERMINAL_RUN_STATES.has(normalizeState(state));
-}

package/vendor/boss-chat-cli/src/runtime/interaction.js

@@ -1,102 +0,0 @@
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function gaussianRandom() {
-  let u = 0;
-  let v = 0;
-  while (u === 0) u = Math.random();
-  while (v === 0) v = Math.random();
-  return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
-}
-
-export function humanDelay(baseMs, varianceMs = 0) {
-  const sampled = baseMs + gaussianRandom() * (varianceMs / 3 || 1);
-  return Math.max(0, Math.round(sampled));
-}
-
-export class InteractionController {
-  constructor(chromeClient, options = {}) {
-    this.chromeClient = chromeClient;
-    this.safePacing = options.safePacing !== false;
-    this.batchRestEnabled = options.batchRestEnabled !== false;
-    this.runControl = options.runControl || null;
-    this.nextRestAt = this.batchRestEnabled ? this.randomRestThreshold() : Number.POSITIVE_INFINITY;
-  }
-
-  randomRestThreshold() {
-    return 15 + Math.floor(Math.random() * 11);
-  }
-
-  async sleepRange(baseMs, varianceMs) {
-    const delay = this.safePacing ? humanDelay(baseMs, varianceMs) : baseMs;
-    await this.wait(delay);
-    return delay;
-  }
-
-  async wait(ms) {
-    if (this.runControl) {
-      await this.runControl.delay(ms);
-      return;
-    }
-    await sleep(ms);
-  }
-
-  async maybeRest(processedCount, logger = console) {
-    if (!this.batchRestEnabled || processedCount < this.nextRestAt) {
-      return 0;
-    }
-
-    const restMs = 4000 + Math.floor(Math.random() * 4000);
-    logger.log(`短暂休息 ${restMs}ms，保持处理节奏稳定...`);
-    await this.wait(restMs);
-    this.nextRestAt = processedCount + this.randomRestThreshold();
-    return restMs;
-  }
-
-  async moveMouseNear(targetX, targetY) {
-    const steps = this.safePacing ? 4 + Math.floor(Math.random() * 3) : 2;
-    const startX = Math.round(targetX - 40 + Math.random() * 30);
-    const startY = Math.round(targetY - 20 + Math.random() * 20);
-
-    for (let index = 1; index <= steps; index += 1) {
-      const progress = index / steps;
-      const x = Math.round(startX + (targetX - startX) * progress + (Math.random() - 0.5) * 4);
-      const y = Math.round(startY + (targetY - startY) * progress + (Math.random() - 0.5) * 4);
-      await this.chromeClient.Input.dispatchMouseEvent({
-        type: 'mouseMoved',
-        x,
-        y,
-      });
-      await this.wait(10 + Math.floor(Math.random() * 25));
-    }
-  }
-
-  async clickRect(rect) {
-    const centerX = rect.left + rect.width / 2;
-    const centerY = rect.top + rect.height / 2;
-    const offsetX = (Math.random() - 0.5) * Math.min(18, rect.width * 0.25);
-    const offsetY = (Math.random() - 0.5) * Math.min(12, rect.height * 0.25);
-    const targetX = Math.round(centerX + offsetX);
-    const targetY = Math.round(centerY + offsetY);
-
-    await this.moveMouseNear(targetX, targetY);
-    await this.sleepRange(180, 80);
-
-    await this.chromeClient.Input.dispatchMouseEvent({
-      type: 'mousePressed',
-      x: targetX,
-      y: targetY,
-      button: 'left',
-      clickCount: 1,
-    });
-    await this.wait(25 + Math.floor(Math.random() * 45));
-    await this.chromeClient.Input.dispatchMouseEvent({
-      type: 'mouseReleased',
-      x: targetX,
-      y: targetY,
-      button: 'left',
-      clickCount: 1,
-    });
-  }
-}