qiksy 1.0.0

package/tools/travel/vendor/server.mjs

@@ -0,0 +1,755 @@
+#!/usr/bin/env node
+/**
+ * Travel Assistant (web) — ассистент командировок на headless-агентах Claude Code.
+ *
+ *   npm start          → http://localhost:5545
+ *
+ * Small JSON API + static UI. Долгие операции (поиск, оформление, финальные
+ * документы) — фоновые джобы, которые спавнят `claude -p` (lib/agent.mjs);
+ * UI поллит /api/state. Архитектура — калька с work-finder.
+ */
+import { createServer } from 'node:http';
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve, extname, sep } from 'node:path';
+
+import { load, save, uid, ROOT, SELF_PARTY_ID } from './lib/store.mjs';
+import { runClaude, extractJson } from './lib/agent.mjs';
+import { buildSearchPrompt, buildBookPrompt, buildFinalizePrompt } from './lib/prompts.mjs';
+import { createJob, jobLog, jobStep, listJobs, getJob, cancelJob, cancelActiveByTrip } from './lib/jobs.mjs';
+import { ensureBrowser } from './scripts/launch-browser.mjs';
+import { PLANS, SELF_SETTABLE_PLANS } from './lib/plans.mjs';
+import { verifyLicense, licensePlanId, RECHECK_MS } from './lib/license.mjs';
+import { probeEngine, startLogin, submitLoginCode } from './lib/engine.mjs';
+import { buildProposalHtml } from './lib/proposal.mjs';
+
+const PORT = Number(process.env.TA_PORT) || 5545;
+const PUBLIC_DIR = resolve(ROOT, 'public');
+const MIME = {
+  '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css',
+  '.json': 'application/json', '.png': 'image/png', '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon', '.woff2': 'font/woff2',
+};
+
+let db = load();
+
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function addActivity(trip, text) {
+  trip.activity.push({ at: Date.now(), text });
+  if (trip.activity.length > 100) trip.activity.splice(0, trip.activity.length - 100);
+}
+
+const touch = trip => { trip.updatedAt = Date.now(); };
+
+/* Маршрут-цепочка (решение владельца 2026-07-20): поездка может нести слоты —
+   упорядоченные отрезки «переезд/трансфер/отель/точка». Санитизируем на входе:
+   только известные типы и строковые поля, максимум 12 слотов. Пустой массив =
+   классический простой режим from→to. */
+const LEG_KINDS = ['transport', 'transfer', 'hotel', 'point'];
+const TRAVEL_CLASSES = ['economy', 'premium', 'business'];
+const PRIORITIES = ['cheapest', 'optimal', 'fastest', 'comfort'];
+const LANGS = ['en', 'ru', 'uk'];
+function sanitizeLegs(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.slice(0, 12).map(l => ({
+    kind: LEG_KINDS.includes(l?.kind) ? l.kind : 'point',
+    from: String(l?.from || '').slice(0, 200),
+    to: String(l?.to || '').slice(0, 200),
+    date: String(l?.date || '').slice(0, 20),
+    mode: String(l?.mode || '').slice(0, 100),
+    near: String(l?.near || '').slice(0, 240),
+    radiusKm: Number(l?.radiusKm) > 0 ? Math.min(20, Number(l.radiusKm)) : 0,
+    note: String(l?.note || '').slice(0, 300),
+  })).filter(l => l.from || l.to || l.near || l.note);
+}
+
+// ── тарифы ─────────────────────────────────────────────────────────────────
+// Эффективный тариф: `dev` — руками (self-host); платные start/pro — только из
+// валидной лицензии. Ручной выбор в настройках ограничен free/dev.
+function effectivePlanId() {
+  if (db.settings.plan === 'dev') return 'dev';
+  return licensePlanId(db.settings.licenseInfo);
+}
+const activePlan = () => PLANS[effectivePlanId()] || PLANS.free;
+
+async function refreshLicense() {
+  const info = await verifyLicense(db.settings.license || '');
+  if (info) { db.settings.licenseInfo = info; save(db); }
+  return db.settings.licenseInfo;
+}
+
+function billingInfo() {
+  const id = effectivePlanId();
+  const p = PLANS[id] || PLANS.free;
+  const li = db.settings.licenseInfo;
+  return {
+    plan: id,
+    planName: p.name,
+    // partyLimit is the paywall (how many people's trips you may run); travelerLimit
+    // only stops a runaway list inside one group. `teamLimit` stays as the old alias
+    // so a UI build from before the group model keeps rendering something sane.
+    partyLimit: isFinite(p.partyLimit) ? p.partyLimit : null,
+    travelerLimit: isFinite(p.travelerLimit) ? p.travelerLimit : null,
+    teamLimit: isFinite(p.travelerLimit) ? p.travelerLimit : null,
+    manualPlan: db.settings.plan,
+    license: {
+      set: !!db.settings.license,
+      key: db.settings.license ? db.settings.license.slice(0, 6) + '…' : '',
+      plan: li && li.plan ? li.plan : 'free',
+      active: !!(li && li.active),
+      invalid: !!(li && li.invalid),
+      paidUntil: (li && li.paidUntil) || 0,
+      trial: !!(li && li.trial),
+      checkedAt: (li && li.checkedAt) || 0,
+    },
+  };
+}
+
+// Паспортные номера не должны утекать в лог джоба (tool_use book-агента несёт
+// их в аргументах) — маскируем каждый известный номер: FK123456 → FK1***56.
+const maskPassport = no => (no.length > 5 ? `${no.slice(0, 3)}***${no.slice(-2)}` : '***');
+function maskSecrets(line) {
+  let out = String(line);
+  for (const m of db.team) {
+    if (m.passportNo && m.passportNo.length >= 4) out = out.split(m.passportNo).join(maskPassport(m.passportNo));
+  }
+  return out;
+}
+
+/** Откат статуса при ошибке джоба; отменённую/удалённую поездку не трогаем. */
+function rollback(trip, fromStatus, toStatus, activityText) {
+  if (trip.status !== fromStatus) return;
+  trip.status = toStatus;
+  addActivity(trip, `✗ ${activityText}`);
+  touch(trip);
+  save(db);
+}
+
+const tripTravelers = trip => trip.travelerIds.map(id => db.team.find(m => m.id === id)).filter(Boolean);
+
+/* Jobs live in memory, trip statuses live on disk — so a server restart (an edit, a
+   crash, a reboot) left trips frozen mid-flight: "searching" forever, with no job
+   behind it and nothing but "Cancel trip" to press. Roll those back at boot and say
+   so in the trip's activity, rather than leaving a dead status on screen. */
+(function recoverInterruptedTrips() {
+  const back = { searching: 'draft', booking: 'options' };
+  let n = 0;
+  for (const t of db.trips) {
+    const to = back[t.status];
+    if (!to) continue;
+    // A search that already produced options is not a loss — keep them and land on
+    // "options" instead of throwing the trip back to an empty draft.
+    t.status = t.status === 'searching' && (t.options || []).length ? 'options' : to;
+    addActivity(t, '⚠ агент прервался (перезапуск сервера) — можно запустить снова');
+    touch(t);
+    n++;
+  }
+  if (n) save(db);
+})();
+
+// ── job workers ────────────────────────────────────────────────────────────
+
+function startSearch(trip) {
+  return createJob('search', trip.id, `Поиск: ${trip.title}`, async (job, signal) => {
+    const t = db.trips.find(x => x.id === trip.id);
+    if (!t) throw new Error('поездка удалена');
+    const travelers = tripTravelers(t);
+
+    // партиалы: агент стримит `OPTION: {...}` — варианты появляются в поездке вживую
+    const onPartial = opt => {
+      if (!opt || !opt.kind || !opt.title) return;
+      if (opt.n == null) opt.n = t.options.length + 1;
+      if (t.options.some(o => o.n === opt.n)) return;
+      t.options.push(opt);
+      touch(t);
+      save(db);
+      jobLog(job, `＋ вариант №${opt.n}: ${opt.title}`);
+      jobStep(job, 'found', opt.title || '', opt.kind || '');
+    };
+
+    const res = await runClaude({
+      prompt: buildSearchPrompt(t, travelers, db.corporate, db.settings, t.lang),
+      allowedTools: ['WebSearch', 'WebFetch'],
+      withBrowser: !!db.settings.browserSearch,
+      model: db.settings.model,
+      timeoutMs: (db.settings.browserSearch ? 25 : 15) * 60_000,
+      signal,
+      onPartial,
+      onEvent: line => jobLog(job, maskSecrets(line)),
+      onStep: (kind, text, host) => jobStep(job, kind, maskSecrets(text), host),
+    });
+    if (!res.ok) {
+      // таймаут/обрыв, но партиалы уже в поездке — частичный успех, не ошибка
+      if (t.status === 'searching' && t.options.length) {
+        t.status = 'options';
+        addActivity(t, `⚠ поиск оборвался (${res.error}), но ${t.options.length} вариантов уже найдено`);
+        touch(t);
+        save(db);
+        jobLog(job, `⚠ ${res.error} — но ${t.options.length} вариантов уже добавлено`);
+        return { options: t.options.length, truncated: true, costUsd: res.costUsd };
+      }
+      rollback(t, 'searching', 'draft', `поиск не удался: ${res.error}`);
+      throw new Error(res.error);
+    }
+    const parsed = extractJson(res.result);
+    if (!parsed || !Array.isArray(parsed.options)) {
+      if (t.status === 'searching' && t.options.length) {
+        t.status = 'options';
+        addActivity(t, `⚠ финальный ответ агента не распарсился, но ${t.options.length} вариантов уже найдено`);
+        touch(t);
+        save(db);
+        jobLog(job, `⚠ финальный ответ не распарсился — но ${t.options.length} вариантов уже добавлено`);
+        return { options: t.options.length, truncated: true, costUsd: res.costUsd };
+      }
+      rollback(t, 'searching', 'draft', 'агент вернул ответ не в формате { options: […] }');
+      throw new Error('agent returned no {options:[…]} JSON: ' + String(res.result).slice(0, 300));
+    }
+    // финальный JSON включает застримленное; нормализуем как в onPartial —
+    // выкидываем неполные, гарантируем уникальный целый n (иначе мёртвая/чужая кнопка)
+    const valid = parsed.options.filter(o => o && o.kind && o.title).slice(0, 5);
+    const usedN = new Set();
+    for (const o of valid) {
+      if (Number.isInteger(o.n) && !usedN.has(o.n)) usedN.add(o.n);
+      else o.n = null;
+    }
+    let nextN = 1;
+    for (const o of valid) {
+      if (o.n != null) continue;
+      while (usedN.has(nextN)) nextN++;
+      o.n = nextN;
+      usedN.add(nextN);
+    }
+    t.options = valid;
+    t.summary = typeof parsed.summary === 'string' ? parsed.summary : '';
+    t.recommendation = { text: '', ids: [], comboTotal: '', ...(parsed.recommendation || {}) };
+    t.notFound = typeof parsed.notFound === 'string' ? parsed.notFound : '';
+    if (t.status === 'searching') t.status = 'options';
+    addActivity(t, `✓ найдено вариантов: ${t.options.length}`);
+    touch(t);
+    save(db);
+    jobLog(job, `✓ найдено вариантов: ${t.options.length}`);
+    return { options: t.options.length, costUsd: res.costUsd };
+  }, () => {
+    const t = db.trips.find(x => x.id === trip.id);
+    if (t) rollback(t, 'searching', 'draft', 'поиск отменён до запуска');
+  });
+}
+
+function startBook(trip, n, prevStatus) {
+  return createJob('book', trip.id, `Оформление №${n}: ${trip.title}`, async (job, signal) => {
+    const t = db.trips.find(x => x.id === trip.id);
+    if (!t) throw new Error('поездка удалена');
+    const option = t.options.find(o => o.n === n);
+    if (!option) throw new Error(`варианта №${n} нет в подборе`);
+    const traveler = db.team.find(m => m.id === t.travelerIds[0]);
+    if (!traveler) throw new Error('у поездки нет путника с карточкой');
+
+    jobLog(job, 'проверяю браузер (CDP :9222)…');
+    if (!(await ensureBrowser())) {
+      rollback(t, 'booking', prevStatus, 'браузер не поднялся на :9222 — запустите npm run browser');
+      throw new Error('браузер не поднялся на :9222');
+    }
+    const res = await runClaude({
+      prompt: buildBookPrompt(t, option, traveler, db.corporate, t.lang),
+      withBrowser: true,
+      allowedTools: ['WebFetch'],
+      model: db.settings.model,
+      timeoutMs: 15 * 60_000,
+      signal,
+      onEvent: line => jobLog(job, maskSecrets(line)),
+      onStep: (kind, text, host) => jobStep(job, kind, maskSecrets(text), host),
+    });
+    if (!res.ok) {
+      rollback(t, 'booking', prevStatus, `оформление №${n} не удалось: ${res.error}`);
+      throw new Error(res.error);
+    }
+    const outcome = extractJson(res.result) || {};
+    t.bookingReports.push({
+      optionN: n,
+      filled: Array.isArray(outcome.filled) ? outcome.filled : [],
+      stoppedAt: outcome.stoppedAt || '',
+      totalShown: outcome.totalShown || '',
+      warnings: Array.isArray(outcome.warnings) ? outcome.warnings : [],
+      manualLink: outcome.manualLink || '',
+      text: outcome.stoppedAt ? '' : String(res.result).slice(0, 1000),
+      at: Date.now(),
+    });
+    if (t.status === 'booking') t.status = 'ready_to_pay';
+    addActivity(t, `✓ вариант №${n}: ${outcome.stoppedAt || 'см. отчёт агента'}${outcome.totalShown ? `, итог ${outcome.totalShown}` : ''} — карту вводит HR`);
+    touch(t);
+    save(db);
+    jobLog(job, `✓ ${outcome.stoppedAt || 'готово'}${outcome.totalShown ? ` · ${outcome.totalShown}` : ''}`);
+    return { optionN: n, ...outcome, costUsd: res.costUsd };
+  }, () => {
+    const t = db.trips.find(x => x.id === trip.id);
+    if (t) rollback(t, 'booking', prevStatus, `оформление №${n} отменено до запуска`);
+  });
+}
+
+function startFinalize(trip) {
+  return createJob('finalize', trip.id, `Документы: ${trip.title}`, async (job, signal) => {
+    const t = db.trips.find(x => x.id === trip.id);
+    if (!t) throw new Error('поездка удалена');
+    const res = await runClaude({
+      prompt: buildFinalizePrompt(t, tripTravelers(t), db.corporate, t.lang),
+      model: db.settings.model,
+      signal,
+      onEvent: line => jobLog(job, maskSecrets(line)),
+    });
+    if (!res.ok) {
+      rollback(t, 'paid', 'ready_to_pay', `документы не сгенерировались: ${res.error}`);
+      throw new Error(res.error);
+    }
+    const parsed = extractJson(res.result);
+    if (!parsed || typeof parsed.letter !== 'string') {
+      rollback(t, 'paid', 'ready_to_pay', 'агент вернул ответ не в формате {letter,costTable,checklist}');
+      throw new Error('agent returned no {letter,costTable,checklist} JSON: ' + String(res.result).slice(0, 300));
+    }
+    t.blocks = {
+      letter: parsed.letter || '',
+      costTable: parsed.costTable || '',
+      checklist: parsed.checklist || '',
+    };
+    addActivity(t, '✓ письмо путнику, смета и чеклист готовы');
+    touch(t);
+    save(db);
+    jobLog(job, '✓ три блока готовы');
+    return { costUsd: res.costUsd };
+  });
+}
+
+// ── http plumbing ──────────────────────────────────────────────────────────
+
+const readBody = req => new Promise((res, rej) => {
+  let data = '';
+  req.on('data', c => { data += c; if (data.length > 2e6) { rej(new Error('тело запроса больше 2 МБ')); req.destroy(); } });
+  req.on('end', () => { try { res(data ? JSON.parse(data) : {}); } catch (e) { rej(e); } });
+  req.on('error', rej);
+});
+
+const json = (res, code, obj) => {
+  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' });
+  res.end(JSON.stringify(obj));
+};
+
+// UI показывает, поднят ли CDP-браузер для оформления броней.
+let browserAlive = false;
+async function probeBrowser() {
+  try {
+    const r = await fetch('http://localhost:9222/json/version', { signal: AbortSignal.timeout(1000) });
+    browserAlive = r.ok;
+  } catch { browserAlive = false; }
+}
+probeBrowser();
+setInterval(probeBrowser, 15_000).unref();
+
+// UI origins allowed to call this local backend cross-origin: the Nx dev
+// servers AND the deployed studio (its static build fetches http://localhost:5545
+// directly — browsers treat localhost as a secure origin, so an https page may).
+const UI_ORIGINS = new Set([
+  'https://studio.qiksy.app',
+  'https://qiksy.app',
+  ...Array.from({ length: 9 }, (_, i) => `http://localhost:${4300 + i}`),
+  'http://localhost:4200',
+  'http://localhost:' + PORT,
+  'http://127.0.0.1:' + PORT,
+]);
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, 'http://x');
+  const path = url.pathname;
+  const seg = path.split('/').filter(Boolean); // e.g. ['api','trips',':id','search']
+
+  // Локальный API отдаёт паспорта: Host-проверка отбивает DNS-rebinding (все методы),
+  // Origin-проверка — CSRF на мутациях: только известные UI-origin'ы (dev-порты +
+  // задеплоенная студия); GET оставлен открытым, иначе рубит no-cors пробу хаба.
+  const host = req.headers.host || '';
+  if (host !== 'localhost:' + PORT && host !== '127.0.0.1:' + PORT) { res.writeHead(403); res.end('bad host'); return; }
+  const origin = req.headers.origin;
+  if (req.method !== 'GET' && req.method !== 'HEAD' && req.method !== 'OPTIONS') {
+    if (origin && !UI_ORIGINS.has(origin)) { res.writeHead(403); res.end('bad origin'); return; }
+  }
+  // CORS для разрешённых UI-origin'ов (эхо конкретного origin, не *).
+  if (origin && UI_ORIGINS.has(origin)) {
+    res.setHeader('Access-Control-Allow-Origin', origin);
+    res.setHeader('Vary', 'Origin');
+    if (req.method === 'OPTIONS') {
+      // Chrome Private Network Access: public qiksy.app → localhost is blocked unless the
+      // preflight carries this header. See the note in client-finder-backend.
+      if (req.headers['access-control-request-private-network'] === 'true') {
+        res.setHeader('Access-Control-Allow-Private-Network', 'true');
+      }
+      res.writeHead(204, {
+        'Access-Control-Allow-Methods': 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+        'Access-Control-Max-Age': '86400',
+      });
+      res.end();
+      return;
+    }
+  }
+
+  try {
+    if (!path.startsWith('/api')) {
+      const file = path === '/' ? 'index.html' : path.slice(1);
+      const full = resolve(PUBLIC_DIR, file);
+      if ((full === PUBLIC_DIR || full.startsWith(PUBLIC_DIR + sep)) && existsSync(full)) {
+        res.writeHead(200, { 'Content-Type': MIME[extname(full)] || 'application/octet-stream' });
+        res.end(readFileSync(full));
+      } else {
+        res.writeHead(404); res.end('not found');
+      }
+      return;
+    }
+
+    // ── state ──
+    /* Start Anthropic's own sign-in on this machine and hand back ITS link, so the
+       panel can offer "open" and "copy" instead of firing a browser off-screen. We
+       never build a "connect with Claude" of our own — this launches theirs, and the
+       panel polls /api/engine until it turns green. */
+    if (req.method === 'POST' && path === '/api/engine/login') {
+      return json(res, 200, await startLogin());
+    }
+
+    /* The callback page shows a code instead of redirecting when it cannot reach the
+       CLI's loopback (another machine, or a browser that won't open localhost). This
+       is where that code goes. */
+    if (req.method === 'POST' && path === '/api/engine/login/code') {
+      const { code } = await readBody(req);
+      return json(res, 200, submitLoginCode(code));
+    }
+
+    /* Can this machine run the agent at all? The gate asks BEFORE demanding a key,
+       because the CLI may already be logged in with a Claude subscription — in which
+       case a key is not just optional, it is irrelevant. ?force=1 re-probes after the
+       user has gone and logged in. */
+    if (req.method === 'GET' && path === '/api/engine') {
+      const force = /[?&]force=1/.test(req.url || '');
+      return json(res, 200, await probeEngine({ force }));
+    }
+
+    if (req.method === 'GET' && path === '/api/state') {
+      return json(res, 200, { ...db, browserAlive, jobs: listJobs(), billing: billingInfo() });
+    }
+
+    // ── jobs ──
+    if (req.method === 'GET' && path === '/api/jobs') {
+      return json(res, 200, listJobs());
+    }
+    if (req.method === 'POST' && seg[1] === 'jobs' && seg[2] && seg[3] === 'cancel') {
+      return json(res, 200, { ok: cancelJob(seg[2]) });
+    }
+    if (req.method === 'GET' && seg[1] === 'jobs' && seg[2]) {
+      const j = getJob(seg[2]);
+      return j ? json(res, 200, j) : json(res, 404, { error: 'нет такого джоба' });
+    }
+
+    // ── free-text route → slots ──
+    // Parsing runs on the local Claude sign-in (the same `claude` CLI the search
+    // agents use), NOT a browser-side Anthropic key — the key path is gone. A cheap,
+    // synchronous one-shot: no background job, just parse and return the legs.
+    if (req.method === 'POST' && path === '/api/parse-route') {
+      const b = await readBody(req);
+      const text = (b.text || '').trim();
+      if (!text) return json(res, 400, { error: 'нужен текст маршрута (text)' });
+      const prompt = `Разбери описание маршрута командировки на упорядоченные слоты. Верни ТОЛЬКО JSON-массив объектов без пояснений:
+[{"kind":"transport|transfer|hotel|point","from":"","to":"","date":"YYYY-MM-DD или пусто","mode":"","near":"","note":""}]
+Правила: переезд города A→B = transport (from/to); такси/экспресс/метро = transfer (mode = способ); отель = hotel (near = адрес/место рядом с которым искать, note = ночи/пожелания); прочие обязательные точки = point (from = место). Обратный путь НЕ добавляй — он строится зеркально автоматически.
+
+ОПИСАНИЕ: ${text}`;
+      try {
+        const r = await runClaude({ prompt, model: 'haiku', timeoutMs: 90_000 });
+        const m = String(r.result || '').match(/\[[\s\S]*\]/);
+        const legs = m ? JSON.parse(m[0]) : [];
+        return json(res, 200, { legs: Array.isArray(legs) ? legs : [] });
+      } catch (e) {
+        return json(res, 500, { error: String(e?.message || e) });
+      }
+    }
+
+    // ── parties (кто едет: своя семья / клиент агентства) ──
+    if (req.method === 'POST' && path === '/api/parties') {
+      const b = await readBody(req);
+      // Тарифная граница живёт ЗДЕСЬ: free ведёт одну группу (себя и семью),
+      // каждая следующая — это чужая поездка, то есть работа агентства.
+      const lim = activePlan().partyLimit;
+      if (db.parties.length >= lim) {
+        return json(res, 402, { error: `PARTY_LIMIT:${lim}` });
+      }
+      const party = {
+        id: 'p_' + uid(),
+        kind: 'client',
+        name: String(b.name || '').trim().slice(0, 120),
+        email: String(b.email || '').trim().slice(0, 160),
+        phone: String(b.phone || '').trim().slice(0, 60),
+        note: String(b.note || '').trim().slice(0, 600),
+        createdAt: Date.now(),
+      };
+      if (!party.name) return json(res, 400, { error: 'нужно имя клиента (name)' });
+      db.parties.push(party);
+      save(db);
+      return json(res, 200, party);
+    }
+    if (req.method === 'PUT' && seg[1] === 'parties' && seg[2]) {
+      const p = db.parties.find(x => x.id === seg[2]);
+      if (!p) return json(res, 404, { error: 'нет такой группы' });
+      const b = await readBody(req);
+      for (const k of ['name', 'email', 'phone', 'note']) if (b[k] !== undefined) p[k] = String(b[k]).slice(0, 600);
+      save(db);
+      return json(res, 200, p);
+    }
+    if (req.method === 'DELETE' && seg[1] === 'parties' && seg[2]) {
+      // Своя группа не удаляется — это «я», а не запись в списке.
+      if (seg[2] === SELF_PARTY_ID) return json(res, 400, { error: 'своя группа не удаляется' });
+      const p = db.parties.find(x => x.id === seg[2]);
+      if (!p) return json(res, 404, { error: 'нет такой группы' });
+      // Каскадно: люди и поездки клиента уходят вместе с ним, иначе остаются
+      // сироты, которые видно только в db.json (UI фильтрует по группе).
+      for (const t of db.trips.filter(t => t.partyId === p.id)) cancelActiveByTrip(t.id);
+      db.trips = db.trips.filter(t => t.partyId !== p.id);
+      db.team = db.team.filter(m => m.partyId !== p.id);
+      db.parties = db.parties.filter(x => x.id !== p.id);
+      save(db);
+      return json(res, 200, { ok: true });
+    }
+
+    // ── team ──
+    if (req.method === 'POST' && path === '/api/team') {
+      const b = await readBody(req);
+      if (!b.nameRu?.trim()) return json(res, 400, { error: 'нужно ФИО (nameRu)' });
+      const partyId = db.parties.some(p => p.id === b.partyId) ? b.partyId : db.parties[0].id;
+      // Внутри группы лимит щедрый и существует только чтобы список не убежал:
+      // тариф считает КЛИЕНТОВ (partyLimit выше), а не членов семьи.
+      const lim = activePlan().travelerLimit;
+      if (db.team.filter(m => m.partyId === partyId).length >= lim) {
+        return json(res, 402, { error: `TRAVELER_LIMIT:${lim}` });
+      }
+      const card = {
+        nameRu: '', nameEn: '', position: '', dob: '', gender: '', citizenship: '',
+        passportNo: '', passportValidUntil: '', email: '', phone: '',
+        loyaltyAir: '', loyaltyHotel: '', notes: '', demo: false,
+        ...b,
+        partyId,
+        id: 't_' + uid(),
+      };
+      db.team.push(card);
+      save(db);
+      return json(res, 200, card);
+    }
+    if (req.method === 'PUT' && seg[1] === 'team' && seg[2]) {
+      const m = db.team.find(x => x.id === seg[2]);
+      if (!m) return json(res, 404, { error: 'нет такой карточки' });
+      const { id, ...fields } = await readBody(req);
+      Object.assign(m, fields);
+      save(db);
+      return json(res, 200, m);
+    }
+    if (req.method === 'DELETE' && seg[1] === 'team' && seg[2]) {
+      db.team = db.team.filter(m => m.id !== seg[2]);
+      save(db);
+      return json(res, 200, { ok: true });
+    }
+
+    // ── corporate / settings ──
+    if (req.method === 'PUT' && path === '/api/corporate') {
+      Object.assign(db.corporate, await readBody(req));
+      save(db);
+      return json(res, 200, db.corporate);
+    }
+    if (req.method === 'PUT' && path === '/api/settings') {
+      const body = await readBody(req);
+      for (const k of ['brandName', 'brandContact', 'brandNote']) {
+        if (k in body) body[k] = String(body[k] || '').slice(0, 400);
+      }
+      // Платные планы включаются лицензией: руками только free/dev.
+      if ('plan' in body && !SELF_SETTABLE_PLANS.includes(body.plan)) delete body.plan;
+      delete body.license;
+      delete body.licenseInfo;
+      Object.assign(db.settings, body);
+      save(db);
+      return json(res, 200, db.settings);
+    }
+
+    // ── license: ввести/сменить/убрать ключ и сразу проверить у воркера ──
+    if (req.method === 'POST' && path === '/api/license') {
+      const { key } = await readBody(req);
+      db.settings.license = typeof key === 'string' ? key.trim() : '';
+      db.settings.licenseInfo = null;
+      save(db);
+      await refreshLicense();
+      return json(res, 200, { billing: billingInfo() });
+    }
+
+    // ── trips CRUD ──
+    if (req.method === 'POST' && path === '/api/trips') {
+      const b = await readBody(req);
+      if (!b.from?.trim() || !b.to?.trim()) return json(res, 400, { error: 'нужны поля from и to (откуда/куда)' });
+      const travelerIds = Array.isArray(b.travelerIds) ? b.travelerIds : [];
+      // Whose trip this is: the body may say, otherwise it follows the travellers
+      // that were picked, otherwise it is the owner's own group.
+      const partyId = db.parties.some(p => p.id === b.partyId)
+        ? b.partyId
+        : db.team.find(m => travelerIds.includes(m.id))?.partyId || db.parties[0].id;
+      const trip = {
+        id: 'trip_' + uid(),
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        partyId,
+        title: (b.title || '').trim() || `${b.from.trim()} → ${b.to.trim()}`,
+        travelerIds,
+        from: b.from.trim(),
+        to: b.to.trim(),
+        departDate: b.departDate || '',
+        returnDate: b.returnDate || '',
+        meetingAt: b.meetingAt || '',
+        budget: b.budget || '',
+        needTransport: b.needTransport !== false,
+        needHotel: b.needHotel !== false,
+        needTransfer: ['auto', 'yes', 'no'].includes(b.needTransfer) ? b.needTransfer : 'auto',
+        // Как везём и что важнее — явные поля, а не догадка из свободного текста
+        // (решение владельца 2026-07-25: HR возит разных людей по-разному).
+        travelClass: TRAVEL_CLASSES.includes(b.travelClass) ? b.travelClass : 'economy',
+        // Which language the agent answers in — the UI's own switch, not a guess.
+        lang: LANGS.includes(b.lang) ? b.lang : 'en',
+        priority: PRIORITIES.includes(b.priority) ? b.priority : 'optimal',
+        criteria: b.criteria || '',
+        // цепочка: якорный адрес (конференция/офис — отель ищется рядом) + слоты
+        anchor: String(b.anchor || '').slice(0, 240),
+        legs: sanitizeLegs(b.legs),
+        status: 'draft',
+        options: [],
+        summary: '',
+        recommendation: { text: '', ids: [], comboTotal: '' },
+        bookingReports: [],
+        blocks: { letter: '', costTable: '', checklist: '' },
+        activity: [],
+      };
+      addActivity(trip, 'поездка создана');
+      db.trips.unshift(trip);
+      save(db);
+      return json(res, 200, trip);
+    }
+    if (seg[1] === 'trips' && seg[2]) {
+      const t = db.trips.find(x => x.id === seg[2]);
+      if (!t) return json(res, 404, { error: 'нет такой поездки' });
+
+      if (req.method === 'PUT' && !seg[3]) {
+        if (!['draft', 'options'].includes(t.status)) {
+          return json(res, 400, { error: `править поездку можно только в статусах draft/options (сейчас: ${t.status})` });
+        }
+        const b = await readBody(req);
+        for (const k of ['title', 'from', 'to', 'departDate', 'returnDate', 'meetingAt', 'budget', 'criteria']) {
+          if (b[k] !== undefined) t[k] = b[k];
+        }
+        if (b.anchor !== undefined) t.anchor = String(b.anchor || '').slice(0, 240);
+        if (b.legs !== undefined) t.legs = sanitizeLegs(b.legs);
+        for (const k of ['needTransport', 'needHotel']) if (b[k] !== undefined) t[k] = !!b[k];
+        if (['auto', 'yes', 'no'].includes(b.needTransfer)) t.needTransfer = b.needTransfer;
+        if (TRAVEL_CLASSES.includes(b.travelClass)) t.travelClass = b.travelClass;
+        if (PRIORITIES.includes(b.priority)) t.priority = b.priority;
+        if (Array.isArray(b.travelerIds)) t.travelerIds = b.travelerIds;
+        if (!String(t.title || '').trim()) t.title = `${t.from} → ${t.to}`;
+        touch(t);
+        save(db);
+        return json(res, 200, t);
+      }
+      if (req.method === 'DELETE' && !seg[3]) {
+        cancelActiveByTrip(t.id);
+        db.trips = db.trips.filter(x => x.id !== t.id);
+        save(db);
+        return json(res, 200, { ok: true });
+      }
+
+      // ── trip actions ──
+      if (req.method === 'POST' && seg[3] === 'search') {
+        // The language is re-read on every run: switch EN→UK in the topbar, search
+        // again, and the new options come back in Ukrainian.
+        const sb = await readBody(req).catch(() => ({}));
+        if (LANGS.includes(sb.lang)) t.lang = sb.lang;
+        if (!['draft', 'options'].includes(t.status)) {
+          return json(res, 400, { error: `поиск доступен из статусов draft/options (сейчас: ${t.status})` });
+        }
+        if (!tripTravelers(t).length) return json(res, 400, { error: 'выберите хотя бы одного путника из команды' });
+        // повторный поиск перезаписывает прошлый подбор
+        t.options = [];
+        t.summary = '';
+        t.recommendation = { text: '', ids: [], comboTotal: '' };
+        t.notFound = '';
+        t.status = 'searching';
+        addActivity(t, 'поиск вариантов запущен');
+        touch(t);
+        save(db);
+        return json(res, 200, { jobId: startSearch(t).id });
+      }
+      if (req.method === 'POST' && seg[3] === 'book') {
+        const { n } = await readBody(req);
+        const num = Number(n);
+        if (!Number.isInteger(num)) return json(res, 400, { error: 'нужен номер варианта: { "n": 2 }' });
+        // из ready_to_pay тоже можно — так оформляется связка (второй вариант следом)
+        if (!['options', 'ready_to_pay'].includes(t.status)) {
+          return json(res, 400, { error: `оформление доступно из статуса options (сейчас: ${t.status})` });
+        }
+        if (!t.options.some(o => o.n === num)) return json(res, 400, { error: `варианта №${num} нет в подборе` });
+        if (!db.team.some(m => m.id === t.travelerIds[0])) return json(res, 400, { error: 'у поездки нет путника с карточкой' });
+        const prev = t.status;
+        t.status = 'booking';
+        addActivity(t, `оформление варианта №${num} запущено`);
+        touch(t);
+        save(db);
+        return json(res, 200, { jobId: startBook(t, num, prev).id });
+      }
+      if (req.method === 'POST' && seg[3] === 'paid') {
+        if (t.status !== 'ready_to_pay') {
+          return json(res, 400, { error: `«Оплачено» доступно из статуса ready_to_pay (сейчас: ${t.status})` });
+        }
+        t.status = 'paid';
+        addActivity(t, 'HR подтвердила оплату — генерирую письмо, смету и чеклист');
+        touch(t);
+        save(db);
+        return json(res, 200, { jobId: startFinalize(t).id });
+      }
+      /* The client proposal: the whole selection as one sendable page (Pro).
+         A GET that returns HTML, so the UI just opens it in a tab — from there it
+         prints to PDF, saves to a file, or gets pasted into a mail. Generated on
+         THIS machine; nothing about the client leaves it. */
+      if (req.method === 'GET' && seg[3] === 'proposal') {
+        const plan = effectivePlanId();
+        if (plan !== 'pro' && plan !== 'dev') { res.writeHead(402); res.end('PARTY_LIMIT'); return; }
+        const lang = ['en', 'ru', 'uk'].includes(url.searchParams.get('lang')) ? url.searchParams.get('lang') : 'en';
+        const html = buildProposalHtml({
+          trip: t,
+          party: db.parties.find(p => p.id === t.partyId) || null,
+          travellers: tripTravelers(t),
+          brand: { name: db.settings.brandName, contact: db.settings.brandContact, note: db.settings.brandNote },
+          lang,
+        });
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(html);
+        return;
+      }
+
+      if (req.method === 'POST' && seg[3] === 'cancel') {
+        t.status = 'cancelled';
+        addActivity(t, 'поездка отменена');
+        touch(t);
+        save(db);
+        cancelActiveByTrip(t.id);
+        return json(res, 200, t);
+      }
+    }
+
+    json(res, 404, { error: 'unknown endpoint' });
+  } catch (err) {
+    json(res, 500, { error: String(err?.message || err) });
+  }
+});
+
+mkdirSync(resolve(ROOT, 'data'), { recursive: true });
+server.listen(PORT, '127.0.0.1', () => {
+  console.log(`Travel Assistant → http://localhost:${PORT}`);
+});
+
+// Проверяем лицензию на старте и раз в 6 часов (best-effort; офлайн не роняет кэш).
+if (db.settings.license) refreshLicense().catch(() => {});
+setInterval(() => { if (db.settings.license) refreshLicense().catch(() => {}); }, RECHECK_MS).unref();