@besales/mcp 0.48.0 → 1.0.0-beta.2

package/scripts/prbr-shipped-compatibility.spec.mjs

@@ -0,0 +1,276 @@
+import { shippedRef } from './shipped-ref.mjs';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { toolDefinitions } from '../src/tools/definitions.ts';
+import { loadShippedDefinitions } from './shipped-definitions.mjs';
+
+const ID = '00000000-0000-4000-8000-000000000001';
+let shipped;
+beforeAll(async () => {
+  const root = fileURLToPath(new URL('..', import.meta.url));
+  const commit = execFileSync('git', ['-C', root, 'rev-parse', shippedRef()], {
+    encoding: 'utf8',
+  }).trim();
+  shipped = (await loadShippedDefinitions(root, commit)).toolDefinitions;
+});
+function request(name, input) {
+  const original = shipped.find((entry) => entry.name === name);
+  expect(original, name).toBeDefined();
+  expect(original.schema.safeParse(input).success, shippedRef() + ':' + name).toBe(true);
+  const current = toolDefinitions.find((entry) => entry.name === name);
+  expect(current.schema.safeParse(input).success, 'v2:' + name).toBe(true);
+  return current.createRequest(current.schema.parse(input));
+}
+
+describe('доводка круг 1: безопасные прежние значения', () => {
+  it.each(['daily', 'hourly'])(
+    'null снимает переопределение только %s через отгруженный вызов',
+    (mode) => {
+      const input = {
+        platform_id: ID,
+        is_enabled: false,
+        explicit_confirmation: true,
+        [`${mode}_prompt`]: null,
+      };
+      const actual = request('besales_scheduled_task_update', input);
+      expect(actual).toEqual({
+        method: 'PATCH',
+        path: `/channels/${ID}/scheduled-tasks/DIALOGUE_ANALYSIS`,
+        body: { isEnabled: false, config: { prompts: { [mode]: null } } },
+      });
+      const current = toolDefinitions.find(
+        (entry) => entry.name === 'besales_scheduled_task_update',
+      );
+      for (const explicit_confirmation of [undefined, false])
+        expect(current.schema.safeParse({ ...input, explicit_confirmation }).success).toBe(false);
+      expect(
+        current.schema.safeParse({ ...input, [`${mode}_prompt`]: 'сырой текст' }).success,
+      ).toBe(false);
+      expect(
+        current.createRequest(
+          current.schema.parse({ platform_id: ID, is_enabled: false, explicit_confirmation: true }),
+        ).body.config,
+      ).not.toHaveProperty('prompts');
+    },
+  );
+
+  it.each([{}, { columns: [{ name: 'obsolete' }] }])(
+    'table_schema=%j принимается и не доезжает до канона',
+    (table_schema) => {
+      const actual = request('besales_knowledge_table_link', {
+        knowledge_space_id: ID,
+        display_name: 'Цены',
+        source: {
+          kind: 'GOOGLE_SHEETS',
+          spreadsheet_url: 'https://docs.google.com/spreadsheets/d/example/edit',
+          table_schema,
+        },
+      });
+      expect(actual.body).toEqual({
+        sourceType: 'TABLE',
+        name: 'Цены',
+        table: {
+          tableName: 'Цены',
+          type: 'GOOGLE_SHEETS',
+          url: 'https://docs.google.com/spreadsheets/d/example/edit',
+        },
+      });
+    },
+  );
+
+  it.each(['WRONG_ACTION', 'MISSED_CONTEXT', 'OTHER'])(
+    'категория %s сохраняется при импорте, фильтрации и выдаче',
+    (category) => {
+      const actual = request('besales_dialogue_audit_import', {
+        platform_id: ID,
+        tickets: ['signed-ticket'],
+        findings: [
+          {
+            ticket: 'signed-ticket',
+            primary_message_id: '1',
+            category,
+            severity: 'MEDIUM',
+            title: 'Наблюдение',
+            description: 'Исходный смысл',
+          },
+        ],
+      });
+      expect(actual.body.findings[0]).toMatchObject({
+        ticket: 'signed-ticket',
+        primaryMessageId: '1',
+        observationType: category,
+        summary: 'Наблюдение\n\nИсходный смысл',
+      });
+      const filtered = request('besales_dialogue_audit_findings', { run_id: ID, category });
+      expect(new URL(filtered.path, 'https://api.test').searchParams.get('observationType')).toBe(
+        category,
+      );
+      const current = toolDefinitions.find(
+        (entry) => entry.name === 'besales_dialogue_audit_findings',
+      );
+      const response = current.enhanceResponse(
+        {
+          items: [
+            {
+              id: ID,
+              observationType: category,
+              severity: 'MEDIUM',
+              details: { type: 'DIALOG_REVIEW', summary: 'Исходный смысл' },
+            },
+          ],
+          truncated: false,
+        },
+        { run_id: ID },
+      );
+      expect(response.items[0].category).toBe(category);
+    },
+  );
+
+  it.each([': ', ' текст '])('непустой образец с пробелами %j сохраняется побайтово', (source) => {
+    const rule = { id: 'whitespace', source, target: '', enabled: true, order: 1 };
+    expect(
+      request('besales_behavior_update', { platform_id: ID, message_filters: [rule] }).body
+        .messageFilters.rules,
+    ).toEqual([rule]);
+  });
+});
+
+describe('решение владельца 19.10: отгруженные формы приняты и приведены к канону', () => {
+  it('прежний XLSX переводится без потери файла, CRM, листов, ключа намерения и согласия', () => {
+    const config = {
+      crmConnectionId: ID,
+      storedFileId: ID,
+      sheets: [{ sheetIndex: 0, outcome: 'won' }],
+    };
+    const input = {
+      icp_id: ID,
+      request_key: ID,
+      gdpr_confirmed: true,
+      mode: 'audio',
+      audio_source_type: 'xlsx_upload',
+      audio_source_config: config,
+    };
+    const actual = request('besales_icp_import_dialogues', input);
+    expect(actual.body).toEqual({
+      requestKey: ID,
+      gdprConfirmed: true,
+      source: { kind: 'xlsx_upload', ...config },
+    });
+    const current = toolDefinitions.find((entry) => entry.name === 'besales_icp_import_dialogues');
+    for (const patch of [
+      { gdpr_confirmed: false },
+      { gdpr_confirmed: undefined },
+      { anonymize: false },
+      { request_key: undefined },
+      { audio_source_config: { ...config, privateSecret: 'refused' } },
+      { audio_source_config: { ...config, storedFileId: 'not-an-id' } },
+    ])
+      expect(current.schema.safeParse({ ...input, ...patch }).success).toBe(false);
+  });
+  it.each(['source', 'target'])('90: длинное поле подмены %s сохраняется без усечения', (field) => {
+    const value = 'x'.repeat(8192);
+    const rule = { id: 'r', source: 'a', target: 'b', enabled: true, order: 1, [field]: value };
+    const actual = request('besales_behavior_update', { platform_id: ID, message_filters: [rule] });
+    expect(actual.body.messageFilters.rules[0][field]).toBe(value);
+    const current = toolDefinitions.find((entry) => entry.name === 'besales_behavior_update');
+    expect(
+      current.schema.safeParse({
+        platform_id: ID,
+        message_filters: [{ ...rule, [field]: value + 'x' }],
+      }).success,
+    ).toBe(false);
+  });
+  it.each([
+    ['account_domain', null, 'accountDomain'],
+    ['account_domain', '', 'accountDomain'],
+    ['departments', null, 'departments'],
+    ['departments', [], 'departments'],
+    ['departments', [{ id: '17', label: 'Отдел продаж' }], 'departments'],
+    ['template_user_id', 17, 'templateUserId'],
+    ['template_user_id', null, 'templateUserId'],
+    ['template_deal_id', 19, 'templateDealId'],
+    ['template_deal_id', null, 'templateDealId'],
+  ])('%s=%j доезжает до атомарной серверной проекции', (field, value, canonical) => {
+    const actual = request('besales_platform_settings_update', {
+      platform_id: ID,
+      getcourse_settings: { [field]: value },
+    });
+    expect(actual.method).toBe('PATCH');
+    expect(actual.path).toBe(`/channels/${ID}/settings`);
+    expect(actual.body.getcourseSettings).toEqual({ [canonical]: value });
+  });
+
+  it.each([undefined, 'Проверяем этот текст'])(
+    'предпросмотр с рассылкой и текстом %j сохраняет оба поля',
+    (message) => {
+      const actual = request('besales_getcourse_cold_welcome_preview', {
+        workspace_id: ID,
+        platform_id: ID,
+        created_after: '2026-09-01T00:00:00.000Z',
+        mailing_variant_id: ID,
+        ...(message === undefined ? {} : { message }),
+      });
+      expect(actual.body).toMatchObject({
+        mailingVariantId: ID,
+        ...(message === undefined ? {} : { message }),
+      });
+    },
+  );
+
+  it.each(['explicit'])('отгруженный список шага mode=%s не расширяется', (mode) => {
+    const actual = request('besales_followup_sequence_upsert', {
+      platform_id: ID,
+      sequence_id: ID,
+      name: 'Цепочка',
+      type: 'INACTIVE_USER_REACTIVATION',
+      trigger: 'USER_INACTIVITY',
+      config: {
+        steps: [
+          {
+            stepType: 'message',
+            messageConfig: { message: 'Текст' },
+            getcourse: {
+              delivery: { mode, transports: ['Telegram', 'Email'] },
+            },
+          },
+        ],
+      },
+    });
+    expect(actual.body.config.steps[0].getcourse.delivery).toEqual({
+      mode: 'explicit',
+      transports: ['Telegram', 'Email'],
+    });
+  });
+
+  it.each(['email', 'phone'])('подтверждённый предел %s — всей строки; усечения нет', (field) => {
+    const value = 'x'.repeat(8192);
+    expect(request('besales_contact_search', { [field]: value }).body[field]).toBe(value);
+    const current = toolDefinitions.find((entry) => entry.name === 'besales_contact_search');
+    expect(current.schema.safeParse({ [field]: value + 'x' }).success).toBe(false);
+  });
+
+  it('ограничения SMS и шага-вебхука сохранены после нормализации', () => {
+    const current = toolDefinitions.find(
+      (entry) => entry.name === 'besales_followup_sequence_upsert',
+    );
+    for (const step of [
+      {
+        getcourse: { delivery: { mode: 'all', transports: ['SMS', 'Email'] } },
+      },
+      {
+        stepType: 'webhook',
+        getcourse: { delivery: { mode: 'explicit', transports: ['Email'] } },
+      },
+    ])
+      expect(
+        current.schema.safeParse({
+          platform_id: ID,
+          name: 'Цепочка',
+          type: 'INACTIVE_USER_REACTIVATION',
+          trigger: 'USER_INACTIVITY',
+          config: { steps: [step] },
+        }).success,
+      ).toBe(false);
+  });
+});

package/scripts/publish-mcp-registry.mjs

@@ -0,0 +1,98 @@
+import { execFileSync } from 'node:child_process';
+import { copyFileSync, existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SPECS_DIR_ENV = 'BESALES_SPECS_CONTRACTS_DIR';
+const API_DIR_ENV = 'BESALES_API_CONTRACTS_DIR';
+const scriptPath = fileURLToPath(import.meta.url);
+const packageRoot = resolve(dirname(scriptPath), '..');
+
+function requiredDirectory(env, name) {
+  const value = env[name]?.trim();
+  if (!value) throw new Error(`${name} обязателен: укажите contracts/ конкретного checkout.`);
+
+  const directory = resolve(packageRoot, value);
+  if (!existsSync(directory)) {
+    throw new Error(`${name} указывает на отсутствующий каталог: ${directory}`);
+  }
+  return directory;
+}
+
+/** Проверяет обе цели до build/copy/emit. */
+export function resolvePublishTargets(env = process.env) {
+  const specsContractsDir = requiredDirectory(env, SPECS_DIR_ENV);
+  const apiContractsDir = requiredDirectory(env, API_DIR_ENV);
+
+  for (const [name, directory] of [
+    [SPECS_DIR_ENV, specsContractsDir],
+    [API_DIR_ENV, apiContractsDir],
+  ]) {
+    const openApi = join(directory, 'openapi-besales-api.yaml');
+    if (!existsSync(openApi)) {
+      throw new Error(`${name} не похож на contracts/: отсутствует ${openApi}`);
+    }
+  }
+
+  const apiRepoRoot = execFileSync('git', ['-C', apiContractsDir, 'rev-parse', '--show-toplevel'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+  if (realpathSync(resolve(apiRepoRoot, 'contracts')) !== realpathSync(apiContractsDir)) {
+    throw new Error(
+      `${API_DIR_ENV} должен быть tracked contracts/ корня выбранного API checkout: ${apiRepoRoot}`,
+    );
+  }
+
+  return { specsContractsDir, apiContractsDir };
+}
+
+function run() {
+  const targets = resolvePublishTargets();
+  const temporaryDir = mkdtempSync(join(tmpdir(), 'besales-mcp-registry-'));
+
+  try {
+    execFileSync('yarn', ['build'], { cwd: packageRoot, stdio: 'inherit' });
+    execFileSync('yarn', ['schemas:sync:trigger-arguments'], {
+      cwd: packageRoot,
+      stdio: 'inherit',
+    });
+    execFileSync('yarn', ['schemas:sync:wave-ids'], {
+      cwd: packageRoot,
+      stdio: 'inherit',
+    });
+    execFileSync('yarn', ['schemas:sync:agent-models'], {
+      cwd: packageRoot,
+      stdio: 'inherit',
+    });
+    execFileSync('yarn', ['schemas:sync:crm-stage-pool'], {
+      cwd: packageRoot,
+      stdio: 'inherit',
+    });
+    copyFileSync(
+      join(packageRoot, 'src/schemas/mcp-tools.json'),
+      join(temporaryDir, 'mcp-tools.json'),
+    );
+    execFileSync(process.execPath, [join(packageRoot, 'scripts/emit-tool-routes.mjs')], {
+      cwd: packageRoot,
+      env: { ...process.env, [API_DIR_ENV]: temporaryDir },
+      stdio: 'inherit',
+    });
+
+    readFileSync(join(temporaryDir, 'mcp-tools.json'), 'utf8');
+    readFileSync(join(temporaryDir, 'mcp-tool-routes.json'), 'utf8');
+    copyFileSync(
+      join(temporaryDir, 'mcp-tools.json'),
+      join(targets.specsContractsDir, 'mcp-tools.json'),
+    );
+    copyFileSync(
+      join(temporaryDir, 'mcp-tool-routes.json'),
+      join(targets.apiContractsDir, 'mcp-tool-routes.json'),
+    );
+  } finally {
+    rmSync(temporaryDir, { recursive: true, force: true });
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === scriptPath) run();

package/scripts/publish-mcp-registry.spec.mjs

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { resolvePublishTargets } from './publish-mcp-registry.mjs';
+
+const temporaryDirectories = [];
+
+afterEach(() => {
+  for (const directory of temporaryDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+function contractsDirectory() {
+  const directory = mkdtempSync(join(tmpdir(), 'besales-contracts-'));
+  temporaryDirectories.push(directory);
+  writeFileSync(join(directory, 'openapi-besales-api.yaml'), 'openapi: 3.1.0\n');
+  return directory;
+}
+
+describe('resolvePublishTargets', () => {
+  it('отказывает до работы, если одна из целей не названа', () => {
+    expect(() => resolvePublishTargets({})).toThrow('BESALES_SPECS_CONTRACTS_DIR обязателен');
+  });
+
+  it('не принимает случайный каталог без OpenAPI', () => {
+    const empty = mkdtempSync(join(tmpdir(), 'besales-empty-'));
+    temporaryDirectories.push(empty);
+    expect(() =>
+      resolvePublishTargets({
+        BESALES_SPECS_CONTRACTS_DIR: empty,
+        BESALES_API_CONTRACTS_DIR: contractsDirectory(),
+      }),
+    ).toThrow('не похож на contracts/');
+  });
+
+  it('не принимает API contracts вне Git checkout', () => {
+    expect(() =>
+      resolvePublishTargets({
+        BESALES_SPECS_CONTRACTS_DIR: contractsDirectory(),
+        BESALES_API_CONTRACTS_DIR: contractsDirectory(),
+      }),
+    ).toThrow();
+  });
+
+  it('принимает явный contracts выбранного API checkout', () => {
+    const apiRoot = mkdtempSync(join(tmpdir(), 'besales-api-'));
+    temporaryDirectories.push(apiRoot);
+    const apiContracts = join(apiRoot, 'contracts');
+    mkdirSync(apiContracts);
+    writeFileSync(join(apiContracts, 'openapi-besales-api.yaml'), 'openapi: 3.1.0\n');
+    execFileSync('git', ['init', '--quiet', apiRoot]);
+
+    expect(
+      resolvePublishTargets({
+        BESALES_SPECS_CONTRACTS_DIR: contractsDirectory(),
+        BESALES_API_CONTRACTS_DIR: apiContracts,
+      }),
+    ).toEqual({
+      specsContractsDir: expect.any(String),
+      apiContractsDir: apiContracts,
+    });
+  });
+});

package/scripts/record-scheduled-task-call.mjs

@@ -0,0 +1,26 @@
+// Запись исполняет отгруженный фильтр и конструктор alias; полное тело хранится в обоих репозиториях.
+import { execFileSync } from 'node:child_process';
+import { shippedRef } from './shipped-ref.mjs';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadShippedDefinitions } from './shipped-definitions.mjs';
+import { scheduledTaskAliasTools } from '../dist/tools/definitions/scheduled-task-alias.js';
+
+const root = fileURLToPath(new URL('..', import.meta.url));
+const apiRoot = process.env.BESALES_API_ROOT;
+if (!apiRoot) throw new Error('BESALES_API_ROOT обязателен');
+const fixturePath = resolve(root, 'src/tools/definitions/__fixtures__/scheduled-task-shipped-call.json');
+const fixture = JSON.parse(readFileSync(fixturePath, 'utf8'));
+const commit = execFileSync('git', ['-C', root, 'rev-parse', shippedRef()], { encoding: 'utf8' }).trim();
+const shipped = await loadShippedDefinitions(root, commit);
+const previous = shipped.toolDefinitions.find((tool) => tool.name === 'besales_scheduled_task_update');
+if (!previous) throw new Error('В отгруженной линии отсутствует отгруженный инструмент настройки');
+const alias = scheduledTaskAliasTools.find((tool) => tool.name === previous.name);
+if (!alias) throw new Error('В текущем мосте отсутствует alias настройки');
+const shippedRequest = previous.createRequest(previous.schema.parse(fixture.input));
+const request = alias.createRequest(alias.schema.parse(fixture.input));
+const out = JSON.stringify({ source: { ref: shippedRef(), commit, recorded: true }, input: fixture.input, shippedRequest, request }, null, 2) + '\n';
+writeFileSync(fixturePath, out);
+writeFileSync(resolve(apiRoot, 'test/mcp-access-accept/fixtures/scheduled-task-shipped-call.json'), out);
+console.log('Записан полный отгруженный вызов и тело alias: ' + commit);

package/scripts/refusal-probe.mjs

@@ -0,0 +1,17 @@
+/** Отказ должен назвать ровно элемент массива и его поле; родительский путь не подходит. */
+export function hasExactRefusalPath(rejected, path) {
+  return !rejected.ok && rejected.refusals.some((item) => item.path === path);
+}
+
+const ICP_ID = '00000000-0000-4000-8000-000000000002';
+const ICP_BASE = { icp_id: ICP_ID, request_key: ICP_ID, gdpr_confirmed: true, mode: 'audio' };
+
+/** Прежняя форма файла должна переводиться в типизированный источник с тем же ключом и согласием. */
+export const ICP_LEGACY_FILE_COMPATIBILITY_CALL = {
+  name: 'besales_icp_import_dialogues',
+  input: {
+    ...ICP_BASE,
+    audio_source_type: 'xlsx_upload',
+    audio_source_config: { crmConnectionId: ICP_ID, storedFileId: ICP_ID },
+  },
+};

package/scripts/refusal-probe.spec.mjs

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+
+import { hasExactRefusalPath } from './refusal-probe.mjs';
+import { filterOf } from './shipped-sample.mjs';
+import { platformSetupTools } from '../src/tools/definitions/platform-setup.js';
+
+describe('адресная проба отказа', () => {
+  /** Мутация, которая красит: оставить только внешний путь invalid_union и потерять поле элемента. */
+  it('message_filters раскрывает вложенный Zod union до source конкретного элемента', () => {
+    const tool = platformSetupTools.find((entry) => entry.name === 'besales_behavior_update');
+    expect(tool).toBeDefined();
+    const rejected = filterOf(tool, '00000000-0000-4000-8000-000000000001')({
+      platform_id: '00000000-0000-4000-8000-000000000001',
+      message_filters: [{ id: 'f1', source: '\uFDD0', target: 'б', enabled: true, order: 1 }],
+    });
+    expect(hasExactRefusalPath(rejected, 'message_filters[].source')).toBe(true);
+    expect(hasExactRefusalPath(rejected, 'message_filters[].target')).toBe(false);
+  });
+  it('общий путь списка не подтверждает отказ source первого элемента', () => {
+    expect(hasExactRefusalPath({ ok: false, refusals: [{ path: 'message_filters' }] },
+      'message_filters[].source')).toBe(false);
+  });
+
+  it('нормализованный путь элемента подтверждает именно своё поле', () => {
+    const rejected = { ok: false, refusals: [{ path: 'message_filters[].source' }] };
+    expect(hasExactRefusalPath(rejected, 'message_filters[].source')).toBe(true);
+    expect(hasExactRefusalPath(rejected, 'message_filters[].target')).toBe(false);
+  });
+});