qiksy 1.0.0

package/tools/work-finder/vendor/lib/engine.mjs

@@ -0,0 +1,283 @@
+/**
+ * Can this machine actually run the agent — and how is it paying?
+ *
+ * The tools are local-first: the work is done by the `claude` CLI on the user's own
+ * machine. That CLI authenticates in one of two ways — a Claude subscription it was
+ * signed into once, or an Anthropic API key. Both work, and they are BILLED FROM
+ * DIFFERENT WALLETS: a claude.ai subscription grants no API credit, and an API key
+ * gives no subscription.
+ *
+ * This matters because the gate used to demand an API key from everyone, and two of
+ * the three tools never even forwarded it — they spawn `claude` with the ambient
+ * environment. So a Max subscriber with a working setup was sent to buy credits for a
+ * credential the engine ignored. The question is not "do you have a key" but "can this
+ * machine run it", and only the machine can answer.
+ *
+ * `claude auth status` answers it for free and instantly — no tokens, no round trip to
+ * Anthropic's inference API. It is also the only way to see the SUBSCRIPTION behind an
+ * API key: with ANTHROPIC_API_KEY set the CLI reports `apiKeySource` and hides the
+ * account, so the probe deliberately runs without it.
+ */
+
+import { spawnClaude } from './spawn-claude.mjs';
+
+const TTL_MS = 60 * 1000;
+
+let cached = null;
+let inflight = null;
+
+function cleanEnv() {
+  const env = { ...process.env };
+  // The same strip the agent runner does: a CLI spawned from inside Claude Code
+  // otherwise inherits markers that change how it behaves.
+  delete env.CLAUDECODE;
+  delete env.CLAUDE_CODE_ENTRYPOINT;
+  // Deliberately removed: the machine's own auth is exactly what we are asking
+  // about. With a key in the environment the CLI reports the key and nothing about
+  // the subscription underneath it.
+  delete env.ANTHROPIC_API_KEY;
+  return env;
+}
+
+function run(args, { timeoutMs = 20_000, detached = false } = {}) {
+  return new Promise((resolve) => {
+    const env = cleanEnv();
+
+    let out = '';
+    let err = '';
+    let done = false;
+    let child;
+    try {
+      child = spawnClaude(args, {
+        env,
+        detached,
+        stdio: detached ? 'ignore' : ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (e) {
+      return resolve({ code: null, out, err: e.code === 'ENOENT' ? 'not-installed' : e.message });
+    }
+    if (detached) {
+      child.unref();
+      return resolve({ code: 0, out, err });
+    }
+
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      child.kill('SIGKILL');
+      resolve({ code: null, out, err: 'timeout' });
+    }, timeoutMs);
+
+    child.stdout.on('data', (d) => (out += d));
+    child.stderr.on('data', (d) => (err += d));
+    child.on('error', (e) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ code: null, out, err: e.code === 'ENOENT' ? 'not-installed' : e.message });
+    });
+    child.on('close', (code) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ code, out, err });
+    });
+  });
+}
+
+function parse(out) {
+  try {
+    const i = out.indexOf('{');
+    const j = out.lastIndexOf('}');
+    return i >= 0 && j > i ? JSON.parse(out.slice(i, j + 1)) : null;
+  } catch {
+    return null;
+  }
+}
+
+async function measure() {
+  const r = await run(['auth', 'status']);
+  if (r.err === 'not-installed') {
+    return { ok: false, mode: 'none', reason: 'cli-missing', account: null, plan: null };
+  }
+  const st = parse(r.out);
+  if (!st) {
+    return {
+      ok: false,
+      mode: 'none',
+      reason: 'cli-broken',
+      account: null,
+      plan: null,
+      detail: (r.err || r.out || '').slice(0, 300),
+    };
+  }
+  if (!st.loggedIn) {
+    return { ok: false, mode: 'none', reason: 'not-authenticated', account: null, plan: null };
+  }
+  // Signed in with a claude.ai account → the subscription pays, no key needed.
+  // Anything else means the CLI is leaning on API billing, which needs credit.
+  const bySubscription = st.authMethod === 'claude.ai' && !st.apiKeySource;
+  return {
+    ok: true,
+    mode: bySubscription ? 'subscription' : 'key',
+    reason: null,
+    account: st.email ?? null,
+    plan: st.subscriptionType ?? null,
+  };
+}
+
+/**
+ * @param {{force?: boolean}} [opts]
+ * @returns {Promise<{ok:boolean, mode:'subscription'|'key'|'none', reason:string|null,
+ *   account:string|null, plan:string|null, checkedAt:number}>}
+ */
+export async function probeEngine({ force = false } = {}) {
+  if (cached && !force && Date.now() - cached.checkedAt < TTL_MS) return cached;
+  // One probe at a time: three panels opening at once must not spawn three CLIs.
+  if (inflight) return inflight;
+  inflight = measure()
+    .then((r) => {
+      cached = { ...r, checkedAt: Date.now() };
+      return cached;
+    })
+    .finally(() => {
+      inflight = null;
+    });
+  return inflight;
+}
+
+/* ── sign-in ─────────────────────────────────────────────────────────────────
+ * We do not build a "connect with Claude" of our own — there is no such thing for a
+ * third-party app, and faking one would be exactly the wrong instinct. What we do is
+ * run Anthropic's own `claude auth login` here and HAND THE USER ITS LINK.
+ *
+ * The CLI prints the authorize URL on its first line of output and then waits for the
+ * flow to land either way: its loopback callback fires (the browser is on this machine
+ * and can reach it), or the person pastes back the code the callback page shows them.
+ * Both endings are kept open, which is why stdout is READ instead of thrown away and
+ * stdin stays a live pipe — the old version spawned this detached with `stdio:'ignore'`
+ * and so could neither show the link nor accept the code, leaving the user with a
+ * browser tab and a button that had visibly done nothing.
+ */
+
+/** The one login in flight: { child, url, done, ok, startedAt }. */
+let login = null;
+/** An abandoned sign-in must not leave a CLI sitting on the machine forever. */
+const LOGIN_TTL_MS = 10 * 60 * 1000;
+const URL_RE = /(https?:\/\/[^\s"'<>]+)/;
+
+function endLogin() {
+  if (!login || login.done) return;
+  login.done = true;
+  try {
+    login.child.kill('SIGKILL');
+  } catch {
+    /* already gone */
+  }
+}
+
+/**
+ * Launch the sign-in and return the URL to put in front of the user.
+ *
+ * @returns {Promise<{ok:boolean, url?:string, reason?:string}>}
+ */
+export async function startLogin() {
+  /* Idempotent while one is running. Every spawn mints a FRESH PKCE challenge and
+     invalidates the previous one, so re-opening the dialog (or a second panel asking)
+     must hand back the SAME link — otherwise the URL the user already copied dies in
+     their clipboard and the sign-in fails with nothing on screen to explain why. */
+  if (login && !login.done && login.url && Date.now() - login.startedAt < LOGIN_TTL_MS) {
+    return { ok: true, url: login.url };
+  }
+  endLogin();
+
+  const probe = await run(['--version'], { timeoutMs: 10_000 });
+  if (probe.err === 'not-installed') return { ok: false, reason: 'cli-missing' };
+
+  let child;
+  try {
+    child = spawnClaude(['auth', 'login', '--claudeai'], {
+      env: cleanEnv(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch {
+    return { ok: false, reason: 'login-failed' };
+  }
+
+  const state = { child, url: null, done: false, ok: false, startedAt: Date.now() };
+  login = state;
+  cached = null; // the answer is about to change
+
+  const ttl = setTimeout(endLogin, LOGIN_TTL_MS);
+  ttl.unref?.();
+
+  return new Promise((resolve) => {
+    let out = '';
+    let settled = false;
+    const give = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(wait);
+      resolve(r);
+    };
+    /* The URL is printed within a second; if it somehow is not, say so rather than
+       hang the dialog — the CLI may still be opening the browser by itself, which is
+       the pre-existing behaviour and a survivable outcome. */
+    const wait = setTimeout(() => give({ ok: true, url: null }), 12_000);
+
+    const read = (chunk) => {
+      out += chunk;
+      if (!state.url) {
+        // "If the browser didn't open, visit: https://claude.com/cai/oauth/authorize?…"
+        const line = out.split('\n').find((l) => /visit:/i.test(l) && URL_RE.test(l));
+        const m = line?.match(URL_RE);
+        if (m) {
+          state.url = m[1];
+          give({ ok: true, url: m[1] });
+        }
+      }
+      /* The CLI says so out loud when the loopback callback lands. Busting the cache
+         here means the panel's next poll turns green immediately instead of serving a
+         60-second-old "not signed in". */
+      if (/login successful/i.test(out)) {
+        state.ok = true;
+        cached = null;
+      }
+    };
+    child.stdout.on('data', read);
+    child.stderr.on('data', read);
+    child.on('error', () => {
+      state.done = true;
+      give({ ok: false, reason: 'login-failed' });
+    });
+    child.on('close', () => {
+      state.done = true;
+      clearTimeout(ttl);
+      cached = null;
+      give({ ok: !!state.url, url: state.url ?? undefined, reason: state.url ? undefined : 'login-failed' });
+    });
+  });
+}
+
+/**
+ * Hand the CLI the code from the callback page.
+ *
+ * Only needed when the browser could not reach the loopback callback — a different
+ * machine, or a browser that refuses to open localhost. Then Anthropic's page shows a
+ * code instead of redirecting, and this is where it goes.
+ *
+ * @param {string} code
+ * @returns {{ok:boolean, reason?:string}}
+ */
+export function submitLoginCode(code) {
+  const value = String(code ?? '').trim();
+  if (!value) return { ok: false, reason: 'empty-code' };
+  if (!login || login.done || !login.child.stdin.writable) return { ok: false, reason: 'no-login' };
+  try {
+    login.child.stdin.write(value + '\n');
+  } catch {
+    return { ok: false, reason: 'no-login' };
+  }
+  cached = null;
+  return { ok: true };
+}

package/tools/work-finder/vendor/lib/jobs.mjs

@@ -0,0 +1,127 @@
+/** In-memory job registry + tiny concurrency queue (max 2 claude processes). */
+import { EventEmitter } from 'node:events';
+import { uid } from './store.mjs';
+
+/** Live event bus for the SSE stream (GET /api/stream). Every job log line, every
+ *  status transition, and (from server.mjs) every vacancy found is emitted here as a
+ *  single 'event' with a `kind`. The 2.5 s state poll stays the source of truth; this
+ *  bus only pushes the same facts instantly so the live-agent theatre feels real-time.
+ *  Many tabs may subscribe, so lift the default 10-listener cap. */
+export const jobEvents = new EventEmitter();
+jobEvents.setMaxListeners(64);
+/** Emit a job status/transition frame. */
+function emitJob(job) {
+  jobEvents.emit('event', { kind: 'job', jobId: job.id, jobType: job.type, label: job.label, status: job.status, at: Date.now() });
+}
+
+const jobs = new Map();
+const controllers = new Map(); // job.id → AbortController (только у выполняющихся)
+const MAX_CONCURRENT = 2;
+let running = 0;
+const queue = [];
+
+export function createJob(type, label, work) {
+  const job = {
+    id: uid(),
+    type,
+    label,
+    status: 'queued',
+    log: [],
+    result: null,
+    error: null,
+    createdAt: Date.now(),
+    finishedAt: null,
+  };
+  jobs.set(job.id, job);
+  queue.push({ job, work });
+  pump();
+  // Keep the registry bounded.
+  if (jobs.size > 100) {
+    const finished = [...jobs.values()].filter(j => j.finishedAt).sort((a, b) => a.finishedAt - b.finishedAt);
+    for (const old of finished.slice(0, jobs.size - 100)) jobs.delete(old.id);
+  }
+  return job;
+}
+
+function pump() {
+  while (running < MAX_CONCURRENT && queue.length) {
+    const { job, work } = queue.shift();
+    running++;
+    job.status = 'running';
+    emitJob(job);
+    const ac = new AbortController();
+    controllers.set(job.id, ac);
+    jobLog(job, `started: ${job.label}`);
+    Promise.resolve()
+      .then(() => work(job, ac.signal))
+      .then(result => {
+        job.status = 'done';
+        job.result = result ?? null;
+      })
+      .catch(err => {
+        if (ac.signal.aborted) {
+          job.status = 'cancelled';
+          jobLog(job, '⏹ отменено');
+        } else {
+          job.status = 'error';
+          job.error = String(err?.message || err).slice(0, 2000);
+          jobLog(job, `✗ ${job.error}`);
+        }
+      })
+      .finally(() => {
+        emitJob(job);
+        controllers.delete(job.id);
+        job.finishedAt = Date.now();
+        running--;
+        pump();
+      });
+  }
+}
+
+/** Отмена: из очереди — мгновенно, выполняющуюся — через abort (kill агента). */
+export function cancelJob(id) {
+  const job = jobs.get(id);
+  if (!job) return false;
+  if (job.status === 'queued') {
+    const idx = queue.findIndex(q => q.job.id === id);
+    if (idx >= 0) queue.splice(idx, 1);
+    job.status = 'cancelled';
+    job.finishedAt = Date.now();
+    jobLog(job, '⏹ отменено (не начиналось)');
+    emitJob(job);
+    return true;
+  }
+  if (job.status === 'running') {
+    controllers.get(id)?.abort();
+    return true;
+  }
+  return false;
+}
+
+export function cancelActiveByLabel(label) {
+  let n = 0;
+  for (const j of jobs.values()) {
+    if (j.label === label && (j.status === 'running' || j.status === 'queued') && cancelJob(j.id)) n++;
+  }
+  return n;
+}
+
+export function jobLog(job, line) {
+  const stored = `${new Date().toLocaleTimeString('uk-UA')} ${line}`;
+  job.log.push(stored);
+  if (job.log.length > 300) job.log.splice(0, job.log.length - 300);
+  // Push the SAME stored line the poll would deliver, so the client's parseLogLine
+  // handles a streamed line identically — but instantly and without the last-12 cap.
+  jobEvents.emit('event', { kind: 'log', jobId: job.id, jobType: job.type, label: job.label, status: job.status, line: stored, at: Date.now() });
+}
+
+export function listJobs() {
+  return [...jobs.values()]
+    .sort((a, b) => b.createdAt - a.createdAt)
+    .slice(0, 25)
+    .map(j => ({ ...j, log: j.log.slice(-12) }));
+}
+
+export function getJob(id) {
+  return jobs.get(id) || null;
+}

package/tools/work-finder/vendor/lib/license.mjs

@@ -0,0 +1,60 @@
+/**
+ * License verification against the Qiksy licensing worker (products/licenses).
+ *
+ * Local-first: this backend runs on the user's machine, so a plan sitting in
+ * their own db.json can't be trusted — paid tiers are unlocked by a license key
+ * validated HERE. Verification is best-effort and cached in db.settings.licenseInfo:
+ *   • a network failure NEVER downgrades a still-valid cached license (offline grace) —
+ *     it only refuses to UPGRADE without a fresh check;
+ *   • an explicit `{ok:false}` (revoked / wrong product) does drop the plan to free.
+ */
+const LICENSE_API = (process.env.QIKSY_LICENSE_API || 'https://qiksy-licenses.qiksy.workers.dev').replace(/\/+$/, '');
+const PRODUCT = 'workfinder';
+export const RECHECK_MS = 6 * 3600 * 1000; // re-verify at most every 6h
+export const OFFLINE_GRACE_MS = 7 * 86400 * 1000; // trust a cached paid plan up to 7 days offline
+
+/**
+ * Ask the worker about a key. Returns a licenseInfo snapshot, or null when the
+ * check couldn't complete (offline / timeout) so the caller keeps the old cache.
+ * @param {string} key
+ * @returns {Promise<{plan:string, active:boolean, paidUntil:number, trial:boolean, checkedAt:number, invalid?:boolean}|null>}
+ */
+export async function verifyLicense(key) {
+  if (!key) return { plan: 'free', active: false, paidUntil: 0, trial: false, checkedAt: Date.now() };
+  try {
+    const signal = typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(4000) : undefined;
+    const r = await fetch(`${LICENSE_API}/v?key=${encodeURIComponent(key)}&product=${PRODUCT}`, { signal });
+    if (!r.ok) return null;
+    const j = await r.json();
+    if (!j || j.ok === false) return { plan: 'free', active: false, paidUntil: 0, trial: false, checkedAt: Date.now(), invalid: true };
+    return {
+      plan: j.plan || 'free',
+      active: !!j.active,
+      paidUntil: j.paidUntil || 0,
+      trial: !!j.trial,
+      // Team = a Pro license bought on N seats; the worker carries the count. Drives
+      // the candidate limit (server maxProfilesEff). Absent/1 ⇒ individual Pro.
+      seats: Number.isFinite(j.seats) && j.seats > 0 ? j.seats : null,
+      checkedAt: Date.now(),
+    };
+  } catch {
+    return null; // offline: caller keeps the cached licenseInfo
+  }
+}
+
+/**
+ * Effective plan id from a cached licenseInfo. `dev` (self-host) is decided by
+ * the caller before this. Returns 'free' unless the license is a live paid plan
+ * (or within offline grace of one).
+ */
+export function licensePlanId(licenseInfo) {
+  const li = licenseInfo;
+  if (!li || !li.plan || li.plan === 'free') return 'free';
+  const now = Date.now();
+  const notExpired = !li.paidUntil || li.paidUntil > now;
+  if (li.active && notExpired) return li.plan;
+  // offline grace: last check was recent-ish AND the paid term hasn't lapsed
+  const offlineOk = li.checkedAt && now - li.checkedAt < OFFLINE_GRACE_MS;
+  if (offlineOk && li.paidUntil > now) return li.plan;
+  return 'free';
+}

package/tools/work-finder/vendor/lib/linkcheck.mjs

@@ -0,0 +1,72 @@
+/**
+ * Проверка «живости» ссылки на вакансию обычным HTTP-запросом — без токенов.
+ * Мёртвой считаем: HTTP >= 400, страницу-надгробие («job not found», «no longer
+ * accepting»…) или редирект, потерявший хвост пути (Lever так уводит закрытые
+ * вакансии на общий список компании).
+ */
+const TOMBSTONE = new RegExp(
+  [
+    'job (you( are|\\u2019re|\'re)? looking for )?(is |was )?not found',
+    'no longer (accepting|available|active|open|exists)',
+    'position (has been |was )?(filled|closed|removed)',
+    'posting (not found|has closed|is no longer)',
+    'this (job|position|listing|opening) (has |is |was )?(expired|closed|been removed|no longer)',
+    'vacancy (is )?(closed|not found)',
+    'job not found',
+    'page not found',
+    'doesn\\u2019t exist',
+  ].join('|'),
+  'i',
+);
+
+const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36';
+
+export async function checkVacancyUrl(url) {
+  if (!url) return { ok: false, reason: 'нет ссылки' };
+  let res;
+  try {
+    res = await fetch(url, {
+      redirect: 'follow',
+      signal: AbortSignal.timeout(9000),
+      headers: { 'user-agent': UA, accept: 'text/html,*/*' },
+    });
+  } catch {
+    return { ok: false, reason: 'сайт не ответил' };
+  }
+  // 403/429 — почти всегда анти-бот (Cloudflare и т.п.), в браузере страница жива
+  if (res.status === 403 || res.status === 429) return { ok: true, unverified: true };
+  if (res.status >= 400) return { ok: false, reason: `HTTP ${res.status}` };
+
+  // редирект, срезавший идентификатор вакансии из пути → общий список
+  try {
+    const orig = new URL(url);
+    const fin = new URL(res.url || url);
+    const trim = p => p.replace(/\/+$/, '');
+    if (
+      fin.hostname === orig.hostname
+      && trim(fin.pathname) !== trim(orig.pathname)
+      && trim(orig.pathname).startsWith(trim(fin.pathname))
+      && trim(orig.pathname).slice(trim(fin.pathname).length).length > 6
+    ) {
+      return { ok: false, reason: 'редирект на общий список вакансий' };
+    }
+  } catch { /* не критично */ }
+
+  try {
+    const text = (await res.text()).slice(0, 300_000);
+    if (TOMBSTONE.test(text)) return { ok: false, reason: 'страница сообщает, что вакансия закрыта' };
+  } catch { /* тело не дочиталось — не считаем мёртвой */ }
+  return { ok: true };
+}
+
+/** Проверить набор объектов с url параллельно (пачками), вернуть Map url→result. */
+export async function checkMany(urls, concurrency = 8) {
+  const unique = [...new Set(urls.filter(Boolean))];
+  const results = new Map();
+  for (let i = 0; i < unique.length; i += concurrency) {
+    const chunk = unique.slice(i, i + concurrency);
+    const checked = await Promise.all(chunk.map(u => checkVacancyUrl(u)));
+    chunk.forEach((u, idx) => results.set(u, checked[idx]));
+  }
+  return results;
+}

package/tools/work-finder/vendor/lib/linkedin.mjs

@@ -0,0 +1,22 @@
+/**
+ * LinkedIn profile URLs, as people actually have them.
+ *
+ * LinkedIn's own "Copy link to profile" and the browser address bar hand out
+ * `www.linkedin.com/in/name` — no scheme — and the site serves country subdomains
+ * (`ua.linkedin.com`, `de.linkedin.com`). The original check demanded
+ * `https://[www.]linkedin.com/in/` and rejected every one of those as malformed, so a
+ * real profile URL pasted straight from LinkedIn came back "invalid".
+ *
+ * Accept what LinkedIn gives out; store one canonical form.
+ *
+ * @param {string} raw
+ * @returns {string|null} canonical URL, or null if it is not a profile link at all
+ */
+export function normalizeLinkedin(raw) {
+  const bare = String(raw || '')
+    .trim()
+    .replace(/^https?:\/\//i, '')
+    .replace(/^www\./i, '');
+  const m = /^(?:[a-z]{2,3}\.)?linkedin\.com\/in\/([^/?#\s]+)/i.exec(bare);
+  return m ? `https://www.linkedin.com/in/${m[1]}` : null;
+}

package/tools/work-finder/vendor/lib/plans.mjs

@@ -0,0 +1,33 @@
+/**
+ * Тарифы. ЕДИНСТВЕННАЯ ось — количество кандидатов (maxProfiles). Никаких
+ * кредитов и «кошелька»: юзер работает на СВОЁМ ключе Claude, значит частота
+ * запросов упирается в его тариф Claude, а не в нашу валюту. Мы монетизируем
+ * только число юзеров/профилей — обычный разработчик ищет работу себе одному
+ * бесплатно и без ограничений; больше профилей (рекрутеры, агентства) — платно.
+ *
+ * Платные start/pro включаются ТОЛЬКО валидной лицензией (lib/license.mjs) —
+ * local-first, план в db.json доверять нельзя. Руками — только free/dev.
+ * priceUsd/period — для витрины (реальная цена живёт в нашей кассе, MONO_PRICE_*).
+ */
+// ДВЕ оси метрики (owner 2026-07-25): число кандидатов (maxProfiles) И число ролей
+// НА кандидата (maxRoles). Без второй оси один кандидат с 30 ролями = работа десяти
+// кандидатов забесплатно — роли обходили кандидат-лимит. Реальный человек фитит 2–5
+// близких тайтла; РАЗНЫЕ профессии = разные люди = разные кандидаты (Team).
+// Модель цены зафиксирована 2026-07-25: ОДИН глобальный прайс, без регионалки/гейта.
+// Free 1 кандидат · Pro $129/год 1 кандидат · Team = тот же Pro, купленный на N МЕСТ
+// (лицензия несёт `seats`, которое поднимает maxProfiles) — отдельного плана нет.
+// maxRoles — роли НА кандидата (вторая ось метрики, закрывает «30 ролей в одном»).
+export const PLANS = {
+  free: { name: 'Free', maxProfiles: 1, maxRoles: 1, autoApply: false, leads: false, watch: false, priceUsd: 0 },
+  // Pro по умолчанию 1 место; лицензия с seats>1 (Team) поднимает лимит кандидатов
+  // (см. server.mjs maxProfilesEff). Годовой, без помесячной оплаты для индивидуала.
+  // `watch` — мониторинг по расписанию (агент сам перезапускает поиск и ловит новое
+  // раньше рынка); это ГЛАВНЫЙ премиум-аргумент, поэтому только на платном.
+  pro: { name: 'Pro', maxProfiles: 1, maxRoles: 5, autoApply: true, leads: true, watch: true, priceUsd: 129, period: 'yr' },
+  dev: { name: 'Dev — без лимитов', maxProfiles: Infinity, maxRoles: Infinity, autoApply: true, leads: true, watch: true },
+};
+
+/** Планы, которые можно выставить руками в /api/settings (платные — только по лицензии). */
+export const SELF_SETTABLE_PLANS = ['free', 'dev'];
+
+export const monthKey = () => new Date().toISOString().slice(0, 7);