team-chat 0.0.0-stage → 0.3.0

package/cli/lib/agents.js

@@ -0,0 +1,97 @@
+// Агенты этой машины: какие движки есть, конфиг раннера, MCP у Codex, запуск раннера.
+//
+// Сервер называет агенту только движок; команду движка знает только runner.json
+// этой машины. Конфиг пишется один раз — дальше он твой: правь как нужно.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { run, say, start, warn, which } from './util.js';
+import { PACKAGE_ROOT, restartFile } from './server.js';
+
+export const MCP_NAME = 'team-chat';
+
+/** Движки, которые есть на машине, и роль по умолчанию для агента на каждом. */
+export function detectRuntimes() {
+  const found = {};
+  const claude = which('claude');
+  if (claude) found.claude = { bin: claude, role: 'developer' };
+  const codex = which('codex');
+  if (codex) found.codex = { bin: codex, role: 'analyst' };
+  return found;
+}
+
+/** runner.json — если его нет. Существующий не трогаем: его мог поправить человек. */
+export function writeRunnerConfig(home, runtimes) {
+  const file = path.join(home, 'runner.json');
+  if (fs.existsSync(file)) return file;
+
+  const config = { runtimes: {}, trigger_roles: 'any' };
+  if (runtimes.claude) {
+    config.runtimes.claude = {
+      // {mcp_config} — подключение к чату под токеном КОНКРЕТНОГО агента: без него все
+      // агенты на claude писали бы под одним именем. Edit/Write — агент сам вносит правки.
+      // stream-json — ход работы построчно: мост сохраняет его в запись запуска.
+      cmd: `${runtimes.claude.bin} -p --output-format stream-json --verbose `
+        + `--allowedTools Bash Read Grep Glob Edit Write mcp__${MCP_NAME} `
+        + '--strict-mcp-config --mcp-config {mcp_config}',
+      // Урок из запуска пишет дешёвая модель: без инструментов, без MCP, без истории сессий.
+      distill: { cmd: `${runtimes.claude.bin} -p --model haiku --tools "" --strict-mcp-config --no-session-persistence` },
+    };
+  }
+  if (runtimes.codex) {
+    const workspace = path.join(home, 'workspaces', 'codex');
+    fs.mkdirSync(workspace, { recursive: true });
+    config.runtimes.codex = {
+      // --json — ход работы построчно, для записи запуска.
+      cmd: `${runtimes.codex.bin} exec --json --approve-for-me -c sandbox_workspace_write.network_access=true --skip-git-repo-check -`,
+      // Рабочий каталог вне репозиториев: писать в код песочница Codex не даст.
+      cwd: workspace,
+      // Урок из запуска: только чтение, без следа в истории сессий.
+      distill: { cmd: `${runtimes.codex.bin} exec --skip-git-repo-check --ephemeral -s read-only -` },
+      env: { PATH: `${path.dirname(runtimes.codex.bin)}:${process.env.PATH}` },
+    };
+  }
+  fs.writeFileSync(file, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+  return file;
+}
+
+/**
+ * Codex берёт MCP-серверы из своего config.toml, а токен — из переменной окружения,
+ * которую ставит мост. Регистрируем сервер чата один раз; адрес сменился — перерегистрируем.
+ */
+export function registerCodexMcp(chatUrl) {
+  if (!which('codex')) return;
+  const url = `${chatUrl}/mcp`;
+  const list = run('codex', ['mcp', 'list'], { quiet: true }).stdout;
+  const line = list.split('\n').find(l => l.trim().startsWith(MCP_NAME + ' '));
+  if (line && line.includes(url)) return;
+  if (line) run('codex', ['mcp', 'remove', MCP_NAME], { quiet: true });
+  const r = run('codex', ['mcp', 'add', MCP_NAME, '--url', url, '--bearer-token-env-var', 'QBAZAR_CHAT_TOKEN'], { quiet: true });
+  if (r.status === 0) say(`→ Codex: MCP-сервер чата ${MCP_NAME} → ${url}`);
+  else warn(`не удалось подключить MCP чата к Codex: ${r.stderr.trim() || r.stdout.trim()}`);
+}
+
+/** Раннер — Node-процесс из самого пакета; держит мост на каждого агента. */
+export function startRunner(home, { api, token }) {
+  const logs = path.join(home, 'logs');
+  fs.mkdirSync(path.join(home, 'state'), { recursive: true });
+  return start(process.execPath, [path.join(PACKAGE_ROOT, 'bin', 'runner')], {
+    cwd: home,
+    log: path.join(logs, 'runner.log'),
+    env: {
+      ...process.env,
+      CHAT_API: api,
+      CHAT_RUNNER_TOKEN: token,
+      CHAT_RUNNER_CONFIG: path.join(home, 'runner.json'),
+      CHAT_RUNNER_LOGS: logs,
+      CHAT_STATE_DIR: path.join(home, 'state'),
+      CHAT_RUNS_DIR: path.join(home, 'runs'),
+      CHAT_MCP_NAME: MCP_NAME,
+      // Кнопка «перезапустить мосты»: свой сервер кладёт файл в каталог данных. У чужого
+      // сервера файла здесь нет — кнопка не про нас.
+      CHAT_RESTART_FILE: api.startsWith('http://127.0.0.1') || api.startsWith('http://localhost') ? restartFile(home) : '',
+      CHAT_WORKDIR_ROOT: os.homedir(),
+    },
+  });
+}

package/cli/lib/docs.js

@@ -0,0 +1,151 @@
+// Документы ↔ репозитории. Файлы читает и пишет CLI на этой машине; сервер отдаёт
+// подтверждённое и принимает импортированное.
+//
+// Выгрузка замыкает круг: обсуждение живёт в чате, а агент, пишущий код, читает
+// репозиторий. Поэтому наружу уходит ТОЛЬКО статус current, плюс журнал решений и
+// опыт агентов (KNOWLEDGE.md) — в корень каждого репозитория.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { say, warn } from './util.js';
+
+/** Файлы, которые никогда не переносятся в чат: их читает машина или они описывают код. */
+const KEEP_IN_REPO = new Set(['CLAUDE.md', 'AGENTS.md', 'README.md', 'CHANGELOG.md', 'DECISIONS.md', 'KNOWLEDGE.md']);
+const OWN_REPO = 'team-chat';
+
+/** Записать подтверждённые документы, DECISIONS.md и KNOWLEDGE.md. → сколько файлов записано (или было бы). */
+export function exportDocs({ chat, documents, decisions, knowledge = [] }, root, dryRun) {
+  let written = 0;
+  if (documents.length === 0) {
+    warn('подтверждённых документов нет — выгружать нечего. Статус current ставит владелец.');
+  }
+  for (const doc of documents) {
+    if (!doc.origin) {
+      warn(`${doc.slug}: не задан путь в репозитории — пропущен`);
+      continue;
+    }
+    const target = path.join(root, doc.origin);
+    say(`  ${doc.origin}  ← ${doc.slug} (ревизия ${doc.revision})`);
+    if (!dryRun) {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, header(chat, doc) + doc.body);
+    }
+    written++;
+  }
+
+  if (decisions.length) {
+    const body = decisionsMarkdown(decisions);
+    for (const repo of repos(root)) {
+      say(`  ${repo}/DECISIONS.md  ← решений: ${decisions.length}`);
+      if (!dryRun) fs.writeFileSync(path.join(root, repo, 'DECISIONS.md'), body);
+      written++;
+    }
+  }
+
+  if (knowledge.length) {
+    const body = knowledgeMarkdown(chat, knowledge);
+    for (const repo of repos(root)) {
+      say(`  ${repo}/KNOWLEDGE.md  ← уроков: ${knowledge.length}`);
+      if (!dryRun) fs.writeFileSync(path.join(root, repo, 'KNOWLEDGE.md'), body);
+      written++;
+    }
+  }
+  return written;
+}
+
+/** Найти переписку людей в репозиториях: корень, docs/ и Seo/. */
+export function findDocs(root) {
+  const found = [];
+  for (const repo of repos(root)) {
+    for (const dir of ['', 'docs', 'Seo']) {
+      const full = path.join(root, repo, dir);
+      if (!fs.existsSync(full)) continue;
+      for (const name of fs.readdirSync(full).filter(n => n.endsWith('.md') && !KEEP_IN_REPO.has(n)).sort()) {
+        const origin = path.posix.join(repo, dir, name);
+        found.push({
+          slug: origin.toLowerCase().replace(/\//g, '--').replace(/\.md$/, '').replace(/[ _]/g, '-'),
+          title: name.replace(/\.md$/, ''),
+          kind: kindFor(name),
+          origin,
+          body: fs.readFileSync(path.join(full, name), 'utf8'),
+        });
+      }
+    }
+  }
+  return found;
+}
+
+function repos(root) {
+  return fs.readdirSync(root, { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name !== OWN_REPO && !d.name.startsWith('.'))
+    .map(d => d.name).sort();
+}
+
+/** Тип по имени файла — угадывается, правится потом руками. */
+function kindFor(name) {
+  const n = name.toLowerCase();
+  if (n.includes('plan') || n.includes('redesign')) return 'plan';
+  if (n.includes('audit') || n.includes('review')) return 'audit';
+  if (n.includes('handoff') || n.includes('gaps')) return 'handoff';
+  if (n.includes('report') || n.includes('issues')) return 'report';
+  return 'reference';
+}
+
+/** Шапка выгруженного файла: правки вносятся в чате, иначе копия и оригинал разойдутся. */
+function header(chat, doc) {
+  return [
+    '<!--',
+    `  Сгенерировано из командного чата «${chat.name}». Правки вносятся ТАМ, не здесь:`,
+    `  документ «${doc.slug}», ревизия ${doc.revision}, статус ${doc.status}.`,
+    '  Ручная правка этого файла будет затёрта следующей выгрузкой.',
+    '-->',
+    '',
+    '',
+  ].join('\n');
+}
+
+function decisionsMarkdown(decisions) {
+  const lines = [
+    '# Принятые решения',
+    '',
+    '> Выгружено из командного чата. **Здесь не правят** — решение отменяется',
+    '> выпуском нового в чате, и файл перегенерируется.',
+    '',
+  ];
+  for (const d of decisions) {
+    lines.push(`## №${d.number}. ${d.title}${d.superseded ? ' ~~(отменено)~~' : ''}`, '');
+    if (d.body) lines.push(d.body, '');
+    lines.push(`_${d.decided_by}, ${day(d.decided_at)}${d.supersedes ? `, отменяет №${d.supersedes}_` : '_'}`, '');
+  }
+  return lines.join('\n');
+}
+
+/** Опыт агентов — читают и люди, и агенты, работающие с репозиторием без чата. */
+export function knowledgeMarkdown(chat, lessons) {
+  const lines = [
+    '# Опыт агентов',
+    '',
+    `> Выгружено из командного чата «${chat.name}»: уроки, которые агенты вынесли из своей работы.`,
+    '> **Здесь не правят** — файл перегенерируется. Урок — подсказка: сверяй его с задачей.',
+    '',
+  ];
+  for (const { problem, solution, stack, engine, at } of lessons) {
+    lines.push(`## ${solution.rule}`, '');
+    const item = (label, value) => value && lines.push(`- **${label}:** ${value}`);
+    item('Было', problem && [problem.symptom, problem.area && `(${problem.area})`].filter(Boolean).join(' '));
+    item('Причина', problem?.root_cause);
+    item('Что сработало', solution.approach?.join(' → '));
+    item('Тупики', solution.dead_ends?.join('; '));
+    item('Проверено', solution.verified_by);
+    item('Когда применять', solution.applies_when);
+    item('Стек', stack?.join(', '));
+    lines.push('', `_${[engine, at && day(at)].filter(Boolean).join(', ')}_`, '');
+  }
+  return lines.join('\n');
+}
+
+/** 24.10.2026 — по UTC, как время в базе. */
+function day(iso) {
+  const date = new Date(iso);
+  return `${String(date.getUTCDate()).padStart(2, '0')}.${String(date.getUTCMonth() + 1).padStart(2, '0')}.${date.getUTCFullYear()}`;
+}

package/cli/lib/local.js

@@ -0,0 +1,41 @@
+// Служебные пути запущенного сервера (/api/local/*) — то, что раньше делал `php artisan`.
+// Базу (PGlite) открывает только сервер, поэтому команды CLI идут через него.
+
+import { die } from './util.js';
+
+export class LocalApi {
+  #url;
+  #secret;
+
+  constructor(cfg) {
+    this.#url = `http://127.0.0.1:${cfg.port}/api/local`;
+    this.#secret = cfg.localSecret;
+  }
+
+  get(path) {
+    return this.#request('GET', path);
+  }
+
+  post(path, body = {}) {
+    return this.#request('POST', path, body);
+  }
+
+  async #request(method, path, body) {
+    let res;
+    try {
+      res = await fetch(this.#url + path, {
+        method,
+        headers: { 'X-Local-Secret': this.#secret, Accept: 'application/json', ...(body ? { 'Content-Type': 'application/json' } : {}) },
+        body: body ? JSON.stringify(body) : undefined,
+      });
+    } catch {
+      die('чат не запущен на этой машине — сначала team-chat start');
+    }
+    const data = await res.json().catch(() => null);
+    if (!res.ok) {
+      const errors = data?.errors ? Object.values(data.errors).flat().join(' ') : null;
+      die(errors || data?.message || `сервер ответил ${res.status}`);
+    }
+    return data;
+  }
+}

package/cli/lib/server.js

@@ -0,0 +1,52 @@
+// Сервер чата — Node-процесс из самого пакета (server/dist). Никаких PHP, composer и
+// Docker: всё окружение задаёт CLI, данные живут в каталоге данных.
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { start } from './util.js';
+
+export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const PKG = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+export const VERSION = PKG.version;
+
+const SERVER_MAIN = path.join(PACKAGE_ROOT, 'server', 'dist', 'src', 'main.js');
+
+export function defaultHome() {
+  return process.env.TEAM_CHAT_HOME || path.join(os.homedir(), '.team-chat');
+}
+
+/** Секрет служебных путей сервера — для команд CLI этой машины. Живёт в config.json (600). */
+export function newSecret() {
+  return crypto.randomBytes(32).toString('hex');
+}
+
+/** Запрос «перезапустить мосты»: сервер кладёт, раннер этой машины забирает. */
+export function restartFile(home) {
+  return path.join(home, 'bridge-restart.request');
+}
+
+/** Поднять сервер. Возвращает процесс; вывод — в <данные>/logs/server.log. */
+export function startServer(home, cfg) {
+  return start(process.execPath, [SERVER_MAIN], {
+    log: path.join(home, 'logs', 'server.log'),
+    env: {
+      ...process.env,
+      CHAT_DATA_DIR: home,
+      CHAT_PORT: String(cfg.port),
+      CHAT_URL: `http://localhost:${cfg.port}`,
+      CHAT_LOCAL_SECRET: cfg.localSecret,
+      CHAT_BRIDGE_RESTART_FILE: restartFile(home),
+    },
+  });
+}
+
+/**
+ * Данные прежней, PHP-версии пакета (до 0.3): SQLite в каталоге данных. Новый сервер её
+ * не читает — перенос делается дампом.
+ */
+export function legacyData(home) {
+  return fs.existsSync(path.join(home, 'chat.sqlite')) && !fs.existsSync(path.join(home, 'db'));
+}

package/cli/lib/util.js

@@ -0,0 +1,107 @@
+// Мелочи без зависимостей: процессы, файлы, вывод. CLI ставится из git — никаких
+// node_modules, только стандартная библиотека Node.
+
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+
+export const say = (...parts) => console.log(...parts);
+export const warn = (...parts) => console.error('⚠', ...parts);
+
+export function die(message, code = 1) {
+  console.error('✗ ' + message);
+  process.exit(code);
+}
+
+/** Есть ли команда в PATH. */
+export function which(cmd) {
+  const r = spawnSync(process.platform === 'win32' ? 'where' : 'which', [cmd], { encoding: 'utf8' });
+  return r.status === 0 ? r.stdout.split('\n')[0].trim() : null;
+}
+
+/** Запустить и дождаться; вывод — в лог или на экран. Возвращает {status, stdout, stderr}. */
+export function run(cmd, args, { cwd, env, quiet = false, input } = {}) {
+  const r = spawnSync(cmd, args, {
+    cwd, env, input, encoding: 'utf8',
+    stdio: quiet ? ['pipe', 'pipe', 'pipe'] : ['pipe', 'pipe', 'inherit'],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (r.error) return { status: 127, stdout: '', stderr: String(r.error.message) };
+  return { status: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+}
+
+/** Долгоживущий процесс со своей группой: остановка гасит и всех его детей. */
+export function start(cmd, args, { cwd, env, log }) {
+  fs.mkdirSync(path.dirname(log), { recursive: true });
+  const out = fs.openSync(log, 'a');
+  const child = spawn(cmd, args, { cwd, env, stdio: ['ignore', out, out], detached: true });
+  fs.closeSync(out);
+  return child;
+}
+
+export function stop(child, signal = 'SIGTERM') {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  try { process.kill(-child.pid, signal); } catch { try { child.kill(signal); } catch { /* уже нет */ } }
+}
+
+export function alive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+export function readJson(file, fallback = null) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
+}
+
+/** Записать JSON с правами 600: в конфиге токены. */
+export function writeJson(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+  fs.chmodSync(file, 0o600);
+}
+
+/** Открыть ссылку в браузере — где это умеется. Не вышло — ссылка всё равно напечатана. */
+export function openBrowser(url) {
+  const wsl = process.platform === 'linux' && /microsoft/i.test(os.release());
+  const tries = process.platform === 'darwin' ? [['open', [url]]]
+    : wsl ? [['wslview', [url]], ['cmd.exe', ['/c', 'start', '', url.replace(/&/g, '^&')]]]
+    : [['xdg-open', [url]]];
+  for (const [cmd, args] of tries) {
+    if (!which(cmd)) continue;
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => {});
+    child.unref();
+    return true;
+  }
+  return false;
+}
+
+/** Свободен ли порт на 127.0.0.1. */
+export function portFree(port) {
+  return new Promise(resolve => {
+    const srv = net.createServer();
+    srv.once('error', () => resolve(false));
+    srv.once('listening', () => srv.close(() => resolve(true)));
+    srv.listen(port, '127.0.0.1');
+  });
+}
+
+/**
+ * Дождаться, пока адрес начнёт отвечать. Если передан процесс сервера — ждём, только
+ * пока он жив: иначе ответ чужого сервера на том же порту сошёл бы за наш.
+ */
+export async function waitHttp(url, timeoutMs = 60000, child = null) {
+  const until = Date.now() + timeoutMs;
+  while (Date.now() < until) {
+    if (child && (child.exitCode !== null || child.signalCode !== null)) return false;
+    try {
+      const r = await fetch(url);
+      if (r.status < 500) return true;
+    } catch { /* ещё не поднялся */ }
+    await sleep(500);
+  }
+  return false;
+}