@besales/mcp 0.47.1 → 1.0.0-beta.2

package/scripts/emit-tool-routes.spec.mjs

@@ -0,0 +1,300 @@
+import { shippedRef } from './shipped-ref.mjs';
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { z } from 'zod';
+
+import { inboundAnalyticsTools } from '../src/tools/definitions/inbound-analytics.ts';
+import { funnelAnalyticsTools } from '../src/tools/definitions/funnel-analytics.ts';
+import { agentDesignTools } from '../src/tools/definitions/agent-design.ts';
+import { dialogueExportTools } from '../src/tools/definitions/dialogue-export.ts';
+import { sampleFor } from './sample-args.mjs';
+import { loadShippedDefinitions } from './shipped-definitions.mjs';
+import { mergeShippedArgs } from './shipped-sample-candidates.mjs';
+import { diffRegistries } from './registry-diff.mjs';
+import { ICP_LEGACY_FILE_COMPATIBILITY_CALL } from './refusal-probe.mjs';
+import {
+  buildShippedSample,
+  filterOf,
+  prepareKnownArgs,
+  resolveShippedVariant,
+  routeShape,
+  schemaLagExplains,
+  schemaPathsOf,
+  variantExtensionFindings,
+} from './shipped-sample.mjs';
+
+const inputRoot = fileURLToPath(new URL('..', import.meta.url));
+const inputWorkspace = '00000000-0000-4000-8000-0000000000ff';
+const inputMap = JSON.parse(
+  readFileSync(new URL('../src/schemas/mcp-v2-route-map.json', import.meta.url), 'utf8'),
+);
+const inputLocalRegistry = JSON.parse(
+  readFileSync(new URL('../src/schemas/mcp-tools.json', import.meta.url), 'utf8'),
+);
+const inputLagRegistry = JSON.parse(
+  readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+);
+let inputShippedRegistry;
+let inputShippedDefinitions;
+
+// Читаем ту же отгруженную линию, что и генератор, без обновления и записи Git.
+beforeAll(async () => {
+  const inputCommit = execFileSync('git', ['-C', inputRoot, 'rev-parse', shippedRef()], {
+    encoding: 'utf8',
+  }).trim();
+  inputShippedRegistry = JSON.parse(
+    execFileSync('git', ['-C', inputRoot, 'show', `${inputCommit}:src/schemas/mcp-tools.json`], {
+      encoding: 'utf8',
+      maxBuffer: 16 * 1024 * 1024,
+    }),
+  );
+  inputShippedDefinitions = (await loadShippedDefinitions(inputRoot, inputCommit)).toolDefinitions;
+}, 60000);
+
+function generatorInput(inputName, inputVariant, inputV2) {
+  const inputShipped = inputShippedDefinitions.find((entry) => entry.name === inputName);
+  const inputShippedSchema = inputShippedRegistry.tools.find(
+    (entry) => entry.name === inputName,
+  ).inputSchema;
+  const inputV2Schema = inputLocalRegistry.tools.find(
+    (entry) => entry.name === inputName,
+  ).inputSchema;
+  const inputShippedPaths = schemaPathsOf(inputShippedSchema, inputName);
+  const inputV2Paths = schemaPathsOf(inputV2Schema, inputName);
+  const inputGenerated = sampleFor(inputName, inputShippedSchema, false);
+  const inputCanonical = inputMap.find(
+    (entry) => entry.tool === `${inputName}@${inputVariant}`,
+  ).canonicalArgs;
+  const inputLag = diffRegistries(
+    inputShippedRegistry.tools,
+    inputLocalRegistry.tools,
+  ).contractLag.filter((entry) => entry.tool === inputName);
+  const inputMain = filterOf(inputV2, inputWorkspace)(inputCanonical);
+  expect(inputMain.ok).toBe(true);
+  const inputKnown = prepareKnownArgs(inputCanonical, inputShippedPaths, {
+    acceptV2: filterOf(inputV2, inputWorkspace),
+    mainRouteShape: routeShape(inputMain.request),
+  });
+  const inputBuild = (inputArgs) =>
+    buildShippedSample({
+      full: mergeShippedArgs(inputGenerated, inputArgs),
+      known: inputArgs,
+      acceptShipped: filterOf(inputShipped, inputWorkspace),
+      acceptV2: filterOf(inputV2, inputWorkspace),
+      explains: (path, args) => schemaLagExplains(path, args, inputLag, inputV2Paths),
+      shippedConstraints: inputShippedPaths,
+      goodValues: () => [],
+      mainRouteShape: routeShape(inputMain.request),
+    });
+  return {
+    known: inputKnown,
+    generated: inputGenerated,
+    schemaLag: inputLag,
+    shippedConstraints: inputShippedPaths,
+    mainRouteShape: routeShape(inputMain.request),
+    build: inputBuild,
+    acceptShipped: filterOf(inputShipped, inputWorkspace),
+  };
+}
+
+describe('генератор отгруженных образцов', () => {
+  it('решение нового переключателя обязательно, адресно и протухает после появления отгруженного варианта', () => {
+    const input = generatorInput('besales_dialogues_query', 'inbox', dialogueExportTools[0]);
+    const outcome = input.build(input.known);
+    const tool = { name: 'besales_dialogues_query', variant: 'inbox', shippedSampleImpossible: outcome.impossible };
+    const args = {
+      tools: [tool], extensions: inputLagRegistry.contractExtensions,
+      shippedSchemas: new Map(inputShippedRegistry.tools.map((item) => [item.name, item.inputSchema])),
+      localSchemas: new Map(inputLocalRegistry.tools.map((item) => [item.name, item.inputSchema])),
+      variantsByTool: new Map([['besales_dialogues_query', [{ variant: 'inbox', args: { source: 'inbox' } }]]]),
+    };
+    expect(variantExtensionFindings(args)).toEqual([]);
+    expect(variantExtensionFindings({ ...args, extensions: {} })).toHaveLength(1);
+    expect(variantExtensionFindings({ ...args, tools: [{ ...tool, shippedSampleImpossible: undefined }] })).toHaveLength(1);
+    expect(variantExtensionFindings({ ...args, shippedSchemas: args.localSchemas })).toHaveLength(1);
+    expect(variantExtensionFindings({ ...args, variantsByTool: new Map() })).toHaveLength(1);
+  });
+  it("inbox не сверяется отгруженным export: неизвестный переключатель сохраняет явную причину", () => {
+    const input = generatorInput(
+      "besales_dialogues_query",
+      "inbox",
+      dialogueExportTools[0],
+    );
+    expect(input.known.source).toBe("inbox");
+    expect(input.known.purchased).toBeUndefined();
+    expect(input.acceptShipped(input.known).ok).toBe(false);
+    const exported = { ...input.known };
+    delete exported.source;
+    expect(input.acceptShipped(exported).ok).toBe(true);
+    expect(routeShape(input.acceptShipped(exported).request)).toBe(
+      "GET /workspaces/:id/dialogue-export",
+    );
+    const outcome = input.build(input.known);
+    expect(outcome.impossible).toEqual({
+      reason: "V2_ONLY_VARIANT",
+      paths: ["source"],
+    });
+    expect(outcome.request).toBeUndefined();
+    expect(outcome.refused).toEqual([]);
+  });
+  it('прежний файл ICP проходит отгруженный фильтр и переводится v2 без потери ключа и согласия', () => {
+    const { name, input } = ICP_LEGACY_FILE_COMPATIBILITY_CALL;
+    const shipped = inputShippedDefinitions.find((entry) => entry.name === name);
+    const current = agentDesignTools.find((entry) => entry.name === name);
+    expect(filterOf(shipped, inputWorkspace)(input).ok).toBe(true);
+    expect(filterOf(current, inputWorkspace)(input).ok).toBe(true);
+    expect(current.createRequest(current.schema.parse(input)).body).toMatchObject({ requestKey: input.request_key, gdprConfirmed: true, source: { kind: 'xlsx_upload', ...input.audio_source_config } });
+  });
+  it('построенные шаблоны Instagram не объявлены отсутствующим маршрутом', () => {
+    const stale = Object.keys(inputLagRegistry.contractLag).filter((key) =>
+      key.startsWith(
+        'besales_platform_settings_update::instagram_comment_behavior.instagram_comment_templates',
+      ),
+    );
+    expect(stale).toEqual([]);
+  });
+
+  it.each(['summary', 'topics', 'speed', 'money', 'cycle', 'quality'])(
+    '%s: настоящий транспорт принимается отгруженной линией и веткой v2, остальные фильтры сохраняются',
+    (inputReport) => {
+      const input = generatorInput(
+        'besales_inbound_analytics_get',
+        inputReport,
+        inboundAnalyticsTools[0],
+      );
+      const inputFull = mergeShippedArgs(input.generated, input.known);
+      expect(inputFull.channels).toEqual(['Telegram']);
+      expect(input.acceptShipped(inputFull).ok).toBe(true);
+      const actualOutcome = input.build(input.known);
+      expect(actualOutcome.impossible).toBeUndefined();
+      expect(actualOutcome.omitted).toEqual([]);
+      const actualUrl = new URL(actualOutcome.request.path, 'https://fixture.test');
+      expect(actualUrl.pathname).toBe(
+        `/workspaces/${input.known.workspace_id}/inbound-analytics/${inputReport}`,
+      );
+      expect(Object.fromEntries(actualUrl.searchParams)).toEqual({
+        channelId: input.known.platform_id,
+        mode: 'days',
+        days: '7',
+        from: '2026-07-01',
+        to: '2026-07-01',
+        transports: 'TELEGRAM',
+      });
+    },
+  );
+
+  it('stage-path: подтверждённый enum после предела перебора — вариант только v2 с путём report', () => {
+    const input = generatorInput(
+      'besales_funnel_analytics_get',
+      'stage-path',
+      funnelAnalyticsTools[0],
+    );
+    const inputOutcome = input.build(input.known);
+    expect(inputOutcome.impossible.reason).toBe('SHIPPED_COMBINATION_LIMIT');
+    const actualOutcome = resolveShippedVariant({ ...input, outcome: inputOutcome });
+    expect(actualOutcome.impossible).toEqual({ reason: 'V2_ONLY_VARIANT', paths: ['report'] });
+    expect(actualOutcome.request).toBeUndefined();
+    expect(actualOutcome.alternatives).toEqual([]);
+  });
+
+  it('доменный образец не меняет соседний channels, явный enum и обязательный минимум', () => {
+    const inputSchema = {
+      type: 'object',
+      properties: { channels: { type: 'array', items: { type: 'string' } } },
+    };
+    expect(sampleFor('besales_other_get', inputSchema, false)).toEqual({ channels: ['x'] });
+    expect(sampleFor('besales_inbound_analytics_get', inputSchema, true)).toEqual({});
+    const inputEnumSchema = {
+      type: 'object',
+      properties: { channels: { type: 'array', items: { type: 'string', enum: ['Whatsapp'] } } },
+    };
+    expect(sampleFor('besales_inbound_analytics_get', inputEnumSchema, false)).toEqual({
+      channels: ['Whatsapp'],
+    });
+    inputEnumSchema.properties.channels.items.enum = ['x'];
+    expect(sampleFor('besales_inbound_analytics_get', inputEnumSchema, false)).toEqual({
+      channels: ['x'],
+    });
+  });
+});
+
+function recoveryInput({
+  inputReason,
+  inputPath = '/things',
+  inputMethod = 'GET',
+  inputRejectV2 = false,
+  inputDeclare = true,
+}) {
+  const inputShippedSchema = z.object({ report: z.enum(['old']) }).strict();
+  const inputV2Schema = z
+    .object({ report: z.enum(inputRejectV2 ? ['new'] : ['old', 'new']) })
+    .strict();
+  const inputRequest = (input) => ({ method: inputMethod, path: inputPath, body: input });
+  const inputShippedPaths = schemaPathsOf(
+    { type: 'object', properties: { report: { type: 'string', enum: ['old'] } } },
+    'отгруженный',
+  );
+  const inputBuild = (input) =>
+    buildShippedSample({
+      full: input,
+      known: input,
+      acceptShipped: filterOf(
+        { schema: inputShippedSchema, createRequest: inputRequest },
+        inputWorkspace,
+      ),
+      acceptV2: filterOf({ schema: inputV2Schema, createRequest: inputRequest }, inputWorkspace),
+      shippedConstraints: inputShippedPaths,
+      explains: () => false,
+      goodValues: () => [],
+      mainRouteShape: 'GET /things',
+    });
+  return {
+    outcome: { impossible: { reason: inputReason, paths: ['a', 'b', 'c', 'd'] } },
+    known: { report: 'new' },
+    generated: { report: 'old' },
+    schemaLag: inputDeclare ? [{ kind: 'CONSTRAINT', path: 'report#enum' }] : [],
+    shippedConstraints: inputShippedPaths,
+    build: inputBuild,
+    mainRouteShape: 'GET /things',
+  };
+}
+
+describe('повтор подтверждённого ограничения', () => {
+  it.each(['SHIPPED_REJECTS_EVERY_SET', 'SHIPPED_COMBINATION_LIMIT'])(
+    '%s: допустимое обоим значение восстанавливает тот же маршрут',
+    (inputReason) => {
+      const actualOutcome = resolveShippedVariant(recoveryInput({ inputReason }));
+      expect(actualOutcome.impossible).toBeUndefined();
+      expect(actualOutcome.request).toEqual({
+        method: 'GET',
+        path: '/things',
+        body: { report: 'old' },
+      });
+    },
+  );
+
+  it.each([{ inputPath: '/other' }, { inputMethod: 'POST' }, { inputRejectV2: true }])(
+    'другой путь, метод либо отказ v2 не выдаются за восстановленный образец: %j',
+    (inputOptions) => {
+      const actualOutcome = resolveShippedVariant(
+        recoveryInput({ inputReason: 'SHIPPED_COMBINATION_LIMIT', ...inputOptions }),
+      );
+      expect(actualOutcome.request).toBeUndefined();
+      expect(actualOutcome.impossible).toEqual({ reason: 'V2_ONLY_VARIANT', paths: ['report'] });
+    },
+  );
+
+  it('без объявленного нарушения enum предел перебора остаётся явным', () => {
+    const input = recoveryInput({ inputReason: 'SHIPPED_COMBINATION_LIMIT', inputDeclare: false });
+    const actualOutcome = resolveShippedVariant(input);
+    expect(actualOutcome).toBe(input.outcome);
+  });
+
+  it('допустимый enum не превращает предел перебора в вариант только v2', () => {
+    const input = recoveryInput({ inputReason: 'SHIPPED_COMBINATION_LIMIT' });
+    input.known.report = 'old';
+    expect(resolveShippedVariant(input)).toBe(input.outcome);
+  });
+});

package/scripts/followup-registry.spec.mjs

@@ -0,0 +1,107 @@
+import { shippedRef } from './shipped-ref.mjs';
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { diffRegistries, lagKey } from './registry-diff.mjs';
+
+const root = new URL('..', import.meta.url).pathname;
+const shipped = JSON.parse(
+  execFileSync('git', ['-C', root, 'show', `${shippedRef()}:src/schemas/mcp-tools.json`], {
+    encoding: 'utf8',
+    maxBuffer: 32 * 1024 * 1024,
+  }),
+);
+const local = JSON.parse(
+  readFileSync(new URL('../src/schemas/mcp-tools.json', import.meta.url), 'utf8'),
+);
+const lag = JSON.parse(
+  readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+);
+const names = [
+  'besales_followup_sequence_upsert',
+  'besales_followup_sequence_list',
+  'besales_followup_step_message_set',
+];
+
+describe('Т54-14: выгрузка формы дожимов', () => {
+  it('новых отставаний нет; расширение доставки до null объявлено отдельно', () => {
+    const diff = diffRegistries(shipped.tools, local.tools, lag.toolSuccessors);
+    expect(diff.missingTools.filter((name) => names.includes(name))).toEqual([]);
+    const nullableDelivery = ['getcourse', 'getcourse.delivery'].map(
+      (path) =>
+        `besales_followup_sequence_upsert::config.steps[].${path}#type::"object"→["object","null"]`,
+    );
+    const followupLag = diff.contractLag.filter((item) => names.includes(item.tool));
+    expect(
+      followupLag
+        .filter((item) => nullableDelivery.includes(lagKey(item)))
+        .map(lagKey)
+        .sort(),
+    ).toEqual([...nullableDelivery].sort());
+    for (const item of followupLag) {
+      if (nullableDelivery.includes(lagKey(item))) {
+        expect(lag.contractLag[lagKey(item)]).toMatchObject({
+          owner: 'DELIBERATE',
+          severity: 'DELIBERATE',
+        });
+      } else {
+        expect(['TASK-6.15.16', 'TASK-6.15.35']).toContain(lag.contractLag[lagKey(item)]?.owner);
+      }
+    }
+    expect(
+      Object.keys(lag.contractLag).filter(
+        (key) =>
+          key.startsWith('besales_followup_sequence_upsert::config.steps[].getcourse') &&
+          key.endsWith('→null'),
+      ),
+    ).toEqual([]);
+    expect(lag.missingTools).not.toHaveProperty('besales_followup_step_message_set');
+  });
+  it('изменение максимума dayOffset обнаруживается именно по #maximum', () => {
+    const broken = globalThis.structuredClone(local.tools);
+    broken.find(
+      (tool) => tool.name === names[0],
+    ).inputSchema.properties.config.properties.steps.items.properties.dayOffset.maximum = 29;
+    expect(diffRegistries(shipped.tools, broken, lag.toolSuccessors).contractLag).toContainEqual(
+      expect.objectContaining({
+        tool: names[0],
+        path: 'config.steps[].dayOffset#maximum',
+        kind: 'CONSTRAINT',
+        shipped: 30,
+        v2: 29,
+      }),
+    );
+  });
+  it('снятие целочисленности окна обнаруживается именно по #type', () => {
+    const inputBroken = globalThis.structuredClone(local.tools);
+    inputBroken.find(
+      (tool) => tool.name === names[0],
+    ).inputSchema.properties.config.properties.steps.items.properties.validityMinutes.type =
+      'number';
+    const actualLag = diffRegistries(shipped.tools, inputBroken, lag.toolSuccessors).contractLag;
+    expect(actualLag).toContainEqual(
+      expect.objectContaining({
+        tool: names[0],
+        path: 'config.steps[].validityMinutes#type',
+        kind: 'CONSTRAINT',
+        shipped: 'integer',
+        v2: 'number',
+      }),
+    );
+  });
+  it('снятие нижней границы окна обнаруживается именно по #minimum', () => {
+    const inputBroken = globalThis.structuredClone(local.tools);
+    delete inputBroken.find((tool) => tool.name === names[0]).inputSchema.properties.config
+      .properties.steps.items.properties.validityMinutes.minimum;
+    const actualLag = diffRegistries(shipped.tools, inputBroken, lag.toolSuccessors).contractLag;
+    expect(actualLag).toContainEqual(
+      expect.objectContaining({
+        tool: names[0],
+        path: 'config.steps[].validityMinutes#minimum',
+        kind: 'CONSTRAINT',
+        shipped: 1,
+        v2: null,
+      }),
+    );
+  });
+});

package/scripts/generate-crm-rotation-contract.mjs

@@ -0,0 +1,98 @@
+// Генерирует локальные формы CRM, сводку и таблицу README; отгруженный реестр не меняет.
+import { readFileSync, writeFileSync } from "node:fs";
+import { z } from "zod";
+// Исходники загружаются штатным TS-loader только при явном --source; сборка остаётся обычным входом.
+const { toolDefinitions } = await import(process.argv.includes('--source')
+  ? '../src/tools/definitions.ts'
+  : '../dist/tools/definitions.js');
+const { renderToolInventoryMarkdown, toolInventoryCounts } = await import(process.argv.includes('--source')
+  ? '../src/tools/inventory.ts'
+  : '../dist/tools/inventory.js');
+const contractPath = new URL("../src/schemas/mcp-tools.json", import.meta.url);
+const routePath = new URL(
+  "../src/schemas/mcp-v2-route-map.json",
+  import.meta.url,
+);
+const contract = JSON.parse(readFileSync(contractPath, "utf8"));
+const routes = JSON.parse(readFileSync(routePath, "utf8"));
+const rotationToolNames = ["besales_crm_rotate_init", "besales_crm_rotate_status"];
+for (const name of rotationToolNames) {
+  const definition = toolDefinitions.find((tool) => tool.name === name);
+  if (!definition) throw new Error(name);
+  const inputSchema = z.toJSONSchema(definition.schema);
+  delete inputSchema.$schema;
+  const tool = {
+    name,
+    description: name.endsWith("init")
+      ? "Сменить ключи существующей CRM через браузер. Секреты не вводить в чат."
+      : "Получить состояние смены ключей CRM. READY не обещает завершённую авторизацию.",
+    inputSchema,
+  };
+  const index = contract.tools.findIndex((tool) => tool.name === name);
+  if (index < 0) contract.tools.push(tool);
+  else contract.tools[index] = tool;
+  const canonicalArgs = {
+    workspace_id: "00000000-0000-4000-8000-000000000001",
+    ...(name.endsWith("init")
+      ? {
+          connection_id: "00000000-0000-4000-8000-000000000002",
+          mode: "GETCOURSE_KEYS",
+        }
+      : { setup_ref: "rotation-ref" }),
+  };
+  const request = definition.createRequest(canonicalArgs);
+  const pathTemplate = request.path
+    .replace(canonicalArgs.workspace_id, ":workspaceId")
+    .replace(
+      canonicalArgs.connection_id ?? "rotation-ref",
+      canonicalArgs.connection_id ? ":connectionId" : ":ref",
+    );
+  const row = {
+    tool: name,
+    canonicalArgs,
+    expected: { ...request, pathTemplate },
+  };
+  const routeIndex = routes.findIndex((row) => row.tool === name);
+  if (routeIndex < 0) routes.push(row);
+  else routes[routeIndex] = row;
+}
+// Регистрация перечисляет эту пару в группе CRM; остальные инструменты сохраняют свой порядок.
+const rotationTools = rotationToolNames.map((name) =>
+  contract.tools.find((tool) => tool.name === name),
+);
+contract.tools = contract.tools.filter((tool) => !rotationToolNames.includes(tool.name));
+const crmOperatorIndex = contract.tools.findIndex(
+  (tool) => tool.name === "besales_crm_operator_update",
+);
+if (crmOperatorIndex < 0) throw new Error("besales_crm_operator_update отсутствует в контракте");
+contract.tools.splice(crmOperatorIndex + 1, 0, ...rotationTools);
+// Сводка и таблица следуют за активными именами, включая добавленные локальные инструменты.
+const toolNames = contract.tools.map((tool) => tool.name);
+const inventoryStart = '<!-- BEGIN GENERATED TOOL INVENTORY -->';
+const inventoryEnd = '<!-- END GENERATED TOOL INVENTORY -->';
+const readmePath = new URL('../README.md', import.meta.url);
+const readme = readFileSync(readmePath, 'utf8');
+const start = readme.indexOf(inventoryStart);
+const end = readme.indexOf(inventoryEnd);
+if (start < 0 || end < start) throw new Error('README inventory markers not found');
+contract.summary.total_tools = toolNames.length;
+contract.summary.tools_by_category = toolInventoryCounts(toolNames);
+const updatedReadme = `${readme.slice(0, start + inventoryStart.length)}\n${renderToolInventoryMarkdown(toolNames)}\n${readme.slice(end)}`;
+writeFileSync(contractPath, `${JSON.stringify(contract, null, 2)}\n`);
+writeFileSync(readmePath, updatedReadme);
+writeFileSync(routePath, `${JSON.stringify(routes, null, 2)}\n`);
+const apiRoutePath = new URL(
+  "../../besales-api/contracts/mcp-v2-route-map.json",
+  import.meta.url,
+);
+const apiRoutes = JSON.parse(readFileSync(apiRoutePath, "utf8"));
+for (const row of routes.filter((row) =>
+  rotationToolNames.includes(row.tool),
+)) {
+  // Опрос ротации тоже требует управления CRM: HTTP-метод не определяет право на сессию смены ключей.
+  const apiRow = { ...row, requiredScopes: ["write:crm"] };
+  const index = apiRoutes.findIndex((old) => old.tool === row.tool);
+  if (index < 0) apiRoutes.push(apiRow);
+  else apiRoutes[index] = apiRow;
+}
+writeFileSync(apiRoutePath, `${JSON.stringify(apiRoutes, null, 2)}\n`);

package/scripts/generate-followup-session-contract.mjs

@@ -0,0 +1,16 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { z } from 'zod';
+import { reactivationConfigSchema } from '../dist/tools/definitions/follow-up-config.js';
+
+// Только добавочные поля: остальные ограничения отгруженной поверхности остаются дословными.
+const file = new URL('../src/schemas/mcp-tools.json', import.meta.url);
+const registry = JSON.parse(readFileSync(file, 'utf8'));
+const tool = registry.tools.find(item => item.name === 'besales_followup_sequence_upsert');
+if (!tool?.inputSchema?.properties?.config?.properties) throw new Error('Нет конфигурации цепочки');
+const derived = z.toJSONSchema(reactivationConfigSchema, { io: 'input', unrepresentable: 'any' });
+for (const field of ['sessionTimeVariable', 'sessionDayOffsets', 'sessionDurationMinutes']) {
+  if (!derived.properties[field]) throw new Error('Не объявлено поле '+field);
+  tool.inputSchema.properties.config.properties[field] = derived.properties[field];
+}
+tool.description = tool.description.replace('непустые dealFields, серия эфиров и неисполняемые виды шагов', 'непустые dealFields и неисполняемые виды шагов');
+writeFileSync(file, JSON.stringify(registry, null, 2)+'\n');

package/scripts/icp-import-verification/mutate.cjs

@@ -0,0 +1,70 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const root = process.cwd();
+const maxMs = Number(process.env.VERIFY_PORTION_MAX_MS ?? 540000);
+if (!Number.isSafeInteger(maxMs) || maxMs <= 0) throw new Error('Invalid VERIFY_PORTION_MAX_MS');
+const manifest = JSON.parse(fs.readFileSync('test/icp-import/mutations.json', 'utf8'));
+const wanted = process.argv.slice(2);
+if (wanted.length === 0 || wanted.some(id => !manifest.some(row => row.id === id)))
+  throw new Error('Supply existing mutant IDs; one invocation is one bounded portion');
+const deadline = Date.now() + maxMs;
+const directory = path.join(root, '.codex-artifacts-codex-icpb14417', 'mutations');
+fs.mkdirSync(directory, { recursive: true });
+const sha = data => crypto.createHash('sha256').update(data).digest('hex');
+function run(row, phase) {
+  const report = path.join(directory, row.id + '-' + phase + '.json');
+  if (fs.existsSync(report)) fs.unlinkSync(report);
+  const args = ['--max-old-space-size=6144', 'node_modules/vitest/vitest.mjs', 'run', '--maxWorkers=2', row.test, '--testNamePattern', row.name, '--reporter=json', '--outputFile', report];
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw new Error('Portion expired before ' + row.id);
+  const processResult = spawnSync(process.execPath, args, {
+    cwd: root, env: process.env, timeout: remaining, killSignal: 'SIGTERM', encoding: 'utf8', maxBuffer: 8 * 1024 * 1024,
+  });
+  fs.writeFileSync(path.join(directory, row.id + '-' + phase + '.log'),
+    processResult.stdout + '\n' + processResult.stderr);
+  const payload = fs.existsSync(report) ? JSON.parse(fs.readFileSync(report, 'utf8')) : null;
+  const failures = (payload?.testResults ?? []).flatMap(suite => suite.assertionResults ?? [])
+    .filter(result => result.status === 'failed' && new RegExp(row.name).test(result.fullName));
+  const targetPath = row.test.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const targetStack = new RegExp('\\bat\\s+[^\\n]*' + targetPath + ':\\d+:\\d+');
+  const targetAssertion = failures.some(result => result.failureMessages.some(message => {
+    const plain = message.replace(/\u001b\[[0-9;]*m/g, '');
+    return /expect\(|AssertionError|Expected:/.test(plain) && targetStack.test(plain);
+  }));
+  return { rc: processResult.status, signal: processResult.signal, timedOut: processResult.error?.code === 'ETIMEDOUT',
+    tested: payload?.numPassedTests ?? 0, failed: payload?.numFailedTests ?? 0, targetAssertion };
+}
+let failed = false;
+for (const row of manifest.filter(row => wanted.includes(row.id))) {
+  const originals = new Map();
+  let result;
+  try {
+    const baseline = run(row, 'control');
+    if (baseline.rc !== 0 || baseline.tested < 1) throw new Error('Control is not green: ' + JSON.stringify(baseline));
+    for (const patch of row.patches) {
+      const file = path.resolve(root, patch.file);
+      if (!file.startsWith(root + path.sep)) throw new Error('Patch escapes root');
+      if (!originals.has(file)) originals.set(file, fs.readFileSync(file));
+      const text = fs.readFileSync(file, 'utf8');
+      if (text.split(patch.from).length - 1 !== patch.count) throw new Error('Patch drift: ' + row.id);
+      fs.writeFileSync(file, text.split(patch.from).join(patch.to));
+    }
+    const mutated = run(row, 'mutant');
+    const state = mutated.rc !== null && mutated.rc !== 0 && !mutated.signal && !mutated.timedOut && mutated.targetAssertion ? 'KILLED'
+      : mutated.rc === 0 ? 'SURVIVED' : 'INFRASTRUCTURE';
+    result = { id: row.id, criterion: row.criterion, state, baseline, mutated };
+  } catch (error) {
+    result = { id: row.id, criterion: row.criterion, state: 'INFRASTRUCTURE', error: String(error) };
+  } finally {
+    for (const [file, content] of originals) {
+      fs.writeFileSync(file, content);
+      if (sha(fs.readFileSync(file)) !== sha(content)) throw new Error('RESTORATION FAILED: ' + file);
+    }
+  }
+  fs.writeFileSync(path.join(directory, row.id + '-result.json'), JSON.stringify(result, null, 2) + '\n');
+  console.log(JSON.stringify(result));
+  if (result.state !== 'KILLED') { failed = true; break; }
+}
+process.exitCode = failed ? 1 : 0;

package/scripts/import-secret-read-contract.mjs

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const [apiRoot, verifierLog] = process.argv.slice(2);
+assert(apiRoot && verifierLog, 'Usage: node scripts/import-secret-read-contract.mjs API_ROOT VREQ_LOG');
+const matches = [...readFileSync(verifierLog, 'utf8').matchAll(/PRSM_BRIDGE_CONTRACT=([A-Za-z0-9+/=]+)/gu)];
+assert.equal(matches.length, 1, 'Exactly one successful API contract is required');
+const contract = JSON.parse(Buffer.from(matches[0][1], 'base64').toString('utf8'));
+assert.equal(contract.version, 1);
+assert.match(contract.apiRevision, /^[a-f0-9]{40}$/u);
+const git = (...args) => execFileSync('git', ['-C', apiRoot, ...args], { encoding: 'utf8' }).trimEnd();
+const localRevision = git('rev-parse', 'HEAD');
+// Канал синхронизирует рабочие файлы, но его Git-метка может отставать. Чужая ветка
+// запрещена; любой изменённый runtime-файл обязан иметь совпавший проверенный хэш.
+git('merge-base', '--is-ancestor', contract.apiRevision, localRevision);
+const roots = ['src', 'scripts/migration'];
+const committed = git('diff', '--name-only', contract.apiRevision, localRevision, '--', ...roots).split('\n').filter(Boolean);
+const uncommitted = git('status', '--porcelain', '--untracked-files=all', '--', ...roots).split('\n').filter(Boolean).map(line => line.slice(3));
+for (const file of new Set([...committed, ...uncommitted])) {
+  if (!file.endsWith('.spec.ts')) assert(Object.hasOwn(contract.sources, file), 'API runtime has unverified changes: ' + file);
+}
+assert.equal(contract.samples.length, 30);
+assert.equal(Object.keys(contract.sources).length, 17);
+const rejectedColumns = contract.columnNames.filter(vector => vector.decision !== 'SAFE').length;
+assert.equal(contract.metadataWrites.length, rejectedColumns + 18);
+assert.equal(contract.metadataWrites.filter(sample => sample.status === 400).length, rejectedColumns + 16);
+assert(contract.metadataWrites.some(sample => JSON.stringify(sample.requestBody).includes('ｇｈｐ_1234567890abcdefghij') && sample.status === 400));
+for (const sample of contract.metadataWrites) {
+  assert([201, 400].includes(sample.status));
+  for (const secret of contract.forbidden)
+    assert(!JSON.stringify(sample.response).includes(JSON.stringify(secret).slice(1, -1)), 'Unsafe metadata write response');
+}
+assert.equal(contract.inventory.version, 1);
+assert.equal(contract.inventory.groups.flatMap(group => group.tools).length, 292);
+for (const [file, expected] of Object.entries(contract.sources)) {
+  assert(/^(?:src|test|scripts)\//u.test(file) && !file.includes('..'));
+  const actual = createHash('sha256').update(readFileSync(resolve(apiRoot, file))).digest('hex');
+  assert.equal(actual, expected, 'API source changed since verification: ' + file);
+}
+for (const sample of contract.samples) {
+  const wire = JSON.stringify(sample.response);
+  for (const secret of contract.forbidden) assert(!wire.includes(JSON.stringify(secret).slice(1, -1)), sample.tool + ': unsafe fixture');
+  assert(sample.principal === 'owner' ? [200, 422].includes(sample.status) : [403, 404].includes(sample.status));
+}
+contract.verifiedApiRevision = localRevision;
+const destination = new URL('../src/tools/__fixtures__/secret-read-contract.json', import.meta.url);
+// Compact wire capture: response bodies are never rewritten.
+mkdirSync(new URL('.', destination), { recursive: true });
+writeFileSync(destination, JSON.stringify(contract) + '\n');
+console.log('Imported ' + contract.samples.length + ' verified HTTP responses; all source hashes and runtime changes match');

package/scripts/install-claude-desktop.js

@@ -11,7 +11,7 @@ const CLAUDE_CONFIG_PATH = join(
   'Library/Application Support/Claude/claude_desktop_config.json',
 );
 const LOCAL_API_BASE_URL = 'http://localhost:3000/api/v2';
-const LOCAL_OAUTH_AUTHORIZE_URL = 'http://localhost:5173/settings/mcp/consent';
+const LOCAL_OAUTH_AUTHORIZE_URL = 'http://localhost:3000/api/v2/auth/mcp-connect/start';
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const packageRoot = dirname(fileURLToPath(new URL('../package.json', import.meta.url)));
 const binPath = join(packageRoot, 'bin/besales-mcp.js');