cli-surf 0.11.0

package/cli.js

@@ -0,0 +1,1239 @@
+#!/usr/bin/env node
+/**
+ * Surf / Opus CLI — терминальный клиент мессенджера.
+ *
+ * Ключевая идея совмещённых лимитов: CLI НЕ имеет своей квоты.
+ * Он логинится тем же пользователем (тот же Bearer-токен / user_id)
+ * и ходит в те же эндпоинты, что и веб-мессенджер:
+ *   GET  /api/ai/usage     — общий месячный бюджет (ai_token_usage)
+ *   POST /api/ai/process   — чат, расходует тот же бюджет через recordAiTokenUsage
+ * Поэтому кредиты, потраченные в терминале, видны в мессенджере, и наоборот.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { normalizeOpusModelId, opusProviderModel } from './opusModels.js';
+import { Spinner, MdStream, usageCard, chatBanner, answerFooter, assistantHead, completer, chatHelp, paint, OPUS_MODEL_IDS, statusLabel, selectArrows, selectNumbered, canUseArrows, modelDisplayName, PICKABLE_MODEL_IDS, normModelKey, setAccentColor, defaultAccentHex, setCliLanguage, tr, isRussian, } from './cliUi.js';
+const VERSION = '0.11.0';
+const DEFAULT_SERVER = 'http://localhost:3001';
+const CONFIG_DIR = path.join(os.homedir(), '.surf-cli');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_PERMISSION_MODE = 'important';
+function loadConfig() {
+    try {
+        const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            server: typeof parsed.server === 'string' && parsed.server ? parsed.server : DEFAULT_SERVER,
+            token: typeof parsed.token === 'string' && parsed.token ? parsed.token : null,
+            accent: typeof parsed.accent === 'string' && parsed.accent ? parsed.accent : null,
+            language: ['en', 'English'].includes(String(parsed.language)) ? 'en' : 'ru',
+            model: typeof parsed.model === 'string' && parsed.model ? parsed.model : null,
+            permissionMode: parsed.permissionMode === 'always' || parsed.permissionMode === 'never'
+                ? parsed.permissionMode
+                : DEFAULT_PERMISSION_MODE,
+        };
+    }
+    catch {
+        return { server: DEFAULT_SERVER, token: null, accent: null, language: 'ru', model: null, permissionMode: DEFAULT_PERMISSION_MODE };
+    }
+}
+function saveConfig(cfg) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+/**
+ * Акцент интерфейса — как в мессенджере: берём accentColor из профиля
+ * (там же, где его меняет пользователь), иначе дефолт мессенджера.
+ * Кэшируем в конфиге, чтобы цвета были свои с первого кадра.
+ */
+function applyAccentFromMe(me) {
+    const settings = me?.uiSettings && typeof me.uiSettings === 'object'
+        ? me.uiSettings
+        : {};
+    const raw = settings.accentColor;
+    const hex = typeof raw === 'string' && raw.trim() ? raw.trim() : defaultAccentHex();
+    setAccentColor(hex);
+    const language = settings.language === 'en' || settings.language === 'English' ? 'en' : 'ru';
+    setCliLanguage(language);
+    const cfg = loadConfig();
+    if (cfg.accent !== hex || cfg.language !== language) {
+        cfg.accent = hex;
+        cfg.language = language;
+        saveConfig(cfg);
+    }
+}
+/** Применить закэшированные настройки мессенджера до любых запросов. */
+function loadSavedAccent() {
+    const { accent, language } = loadConfig();
+    if (accent)
+        setAccentColor(accent);
+    setCliLanguage(language);
+}
+function resolveServer(flagServer) {
+    const fromFlag = flagServer?.trim();
+    if (fromFlag)
+        return fromFlag.replace(/\/+$/, '');
+    const fromEnv = process.env.SURF_SERVER?.trim() || process.env.SURF_API?.trim();
+    if (fromEnv)
+        return fromEnv.replace(/\/+$/, '');
+    return loadConfig().server.replace(/\/+$/, '');
+}
+function getArgValue(args, ...names) {
+    for (let i = 0; i < args.length; i += 1) {
+        for (const name of names) {
+            if (args[i] === name && i + 1 < args.length)
+                return args[i + 1];
+            if (args[i].startsWith(`${name}=`))
+                return args[i].slice(name.length + 1);
+        }
+    }
+    return undefined;
+}
+function hasFlag(args, ...names) {
+    return args.some(a => names.includes(a));
+}
+function resolveUrl(server, p) {
+    if (/^https?:\/\//i.test(p))
+        return p;
+    return `${server}${p.startsWith('/') ? p : `/${p}`}`;
+}
+async function readPassword(prompt) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+        // Пароль piped через stdin (скрипты): скрыть ввод нельзя, читаем строку.
+        const rl = readline.createInterface({ input: stdin, output });
+        const answer = (await rl.question(prompt)).trim();
+        rl.close();
+        return answer;
+    }
+    // Скрытый ввод пароля без внешних зависимостей.
+    return new Promise(resolve => {
+        process.stdout.write(prompt);
+        let value = '';
+        const wasRaw = stdin.isRaw;
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        stdin.resume();
+        const onData = (buf) => {
+            const ch = buf.toString('utf8');
+            if (ch === '\r' || ch === '\n' || ch === '\u0004') {
+                if (stdin.isTTY)
+                    stdin.setRawMode(!!wasRaw);
+                stdin.pause();
+                stdin.removeListener('data', onData);
+                process.stdout.write('\n');
+                resolve(value);
+            }
+            else if (ch === '\u0003') {
+                process.stdout.write('\n');
+                process.exit(130);
+            }
+            else if (ch === '\u007f' || ch === '\b') {
+                value = value.slice(0, -1);
+            }
+            else {
+                value += ch;
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+async function api(server, token, method, p, body) {
+    const res = await fetch(resolveUrl(server, p), {
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    const text = await res.text();
+    let payload;
+    try {
+        payload = text ? JSON.parse(text) : {};
+    }
+    catch {
+        payload = { error: text };
+    }
+    if (!res.ok) {
+        const err = new Error(payload.error || `HTTP ${res.status}`);
+        err.status = res.status;
+        err.payload = payload;
+        throw err;
+    }
+    return payload;
+}
+function printUsage(u) {
+    console.log(usageCard(u));
+}
+function printHelp() {
+    console.log(isRussian() ? `Surf Opus CLI v${VERSION} — терминал поверх тех же лимитов, что и мессенджер.
+Расход один на всех: CLI ходит в /api/ai/process тем же user_id, траты пишет
+в общую таблицу ai_token_usage. Что потратил в терминале — видно в мессенджере.
+
+Использование:
+  surf                                       Чат (если не залогинен — вход через браузер)
+  surf login [--server URL] [--password]     Войти через браузер (с --password — пароль в терминале)
+  surf token <jwt> [--server URL]               Вставить готовый токен из мессенджера
+  surf logout                                   Удалить сохранённый токен
+  surf whoami [--server URL]                    Текущий пользователь
+  surf usage [--server URL] [--json]            Общий лимит/остаток (тот же экран, что в мессенджере)
+  surf models                                   Доступные модели Opus
+  surf ask <текст...> [опции]                   Один вопрос и ответ
+  surf chat [опции]                             Интерактивный чат (стриминг, история)
+  surf get <url...> [--out путь] [--open]       Скачать вложения Opus (нужен тот же токен)
+
+Опции ask/chat:
+  --server URL     Адрес API (или env SURF_SERVER, по умолчанию ${DEFAULT_SERVER})
+  --model <название>  GPT-5 Mini, o3, Gemini… (по умолчанию auto)
+  --no-stream      Не стримить, дождаться полного ответа
+  --attach <path>  Прикрепить файл к вопросу (ask; в chat — команда /attach)
+  --chat-id <N>    Писать в чат мессенджера N (по умолчанию без сохранения — расход лимита тот же)
+  --json           Вывести сырой JSON ответа
+  --yes, -y        Не спрашивать разрешений в этом запуске
+
+Опции get:
+  --out <путь>     Куда сохранить (файл или папка, по умолчанию текущая папка)
+  --open           Открыть скачанное в программе по умолчанию
+
+Команды внутри chat:
+  /usage, /model [id], /permissions, /clear, /help, /logout, /exit, ! — задача с файлами
+` : `Surf Opus CLI v${VERSION} — terminal access to the same limits as the messenger.
+Usage is shared: the CLI uses /api/ai/process under the same user_id and writes
+to the same ai_token_usage table. What is spent in the terminal is visible in the messenger.
+
+Usage:
+  surf                                       Chat (opens browser sign-in when needed)
+  surf login [--server URL] [--password]     Sign in in a browser (--password uses the terminal)
+  surf token <jwt> [--server URL]            Save a messenger token
+  surf logout                                 Remove the saved token
+  surf whoami [--server URL]                 Show the current user
+  surf usage [--server URL] [--json]         Shared usage/remaining limit
+  surf models                                Available Opus models
+  surf ask <text...> [options]               Ask one question
+  surf chat [options]                        Interactive chat (streaming, history)
+  surf get <url...> [--out path] [--open]    Download Opus attachments
+
+ask/chat options:
+  --server URL     API address (or SURF_SERVER; default ${DEFAULT_SERVER})
+  --model <name>   GPT-5 Mini, o3, Gemini… (default: auto)
+  --no-stream      Wait for the complete response
+  --attach <path>  Attach a file (use /attach in chat)
+  --chat-id <N>    Write to messenger chat N (without persistence by default)
+  --json           Print the raw JSON response
+  --yes, -y        Do not ask for agent permissions for this run
+
+get options:
+  --out <path>     Output file or folder (default: current folder)
+  --open           Open with the default application
+
+Chat commands:
+  /usage, /model [id], /permissions, /clear, /help, /logout, /exit, ! — task with files
+`);
+}
+function printModels() {
+    console.log(paint(tr('Модели Opus (лимит общий для всех моделей):', 'Opus models (the limit is shared by all models):'), 'gray'));
+    for (const id of OPUS_MODEL_IDS) {
+        const normalized = normalizeOpusModelId(id);
+        if (id === 'auto') {
+            console.log(`  ${paint('Auto', 'white')} ${paint(tr('(auto) — сама подбирает, по умолчанию', '(auto) — chooses automatically; default'), 'gray')} ${paint(`→ ${opusProviderModel(normalized)}`, 'gray')}`);
+            continue;
+        }
+        console.log(`  ${paint(modelDisplayName(id), 'white')} ${paint(`(${id})`, 'gray')} ${paint(`→ ${opusProviderModel(normalized)}`, 'gray')}`);
+    }
+    console.log(paint(tr('\nfree-план всегда отвечает дешёвой моделью; pro выбирает любую.', '\nThe free plan always uses an economy model; Pro can choose any.'), 'gray'));
+    console.log(paint(tr('При исчерпании месячного лимита включается cheap-mode (GPT-5 Nano).', 'When the monthly limit is exhausted, cheap mode (GPT-5 Nano) is enabled.'), 'gray'));
+}
+async function cmdLogin(args) {
+    const server = resolveServer(getArgValue(args, '--server'));
+    // По умолчанию — вход через браузер (пароль в терминале не нужен).
+    // Старый способ остался для скриптов: surf login --password [email].
+    if (!hasFlag(args, '--password', '-p')) {
+        await startDeviceFlow(server);
+        return;
+    }
+    const positional = args.filter(a => !a.startsWith('--'));
+    let identifier = positional[0];
+    if (!identifier) {
+        const rl = readline.createInterface({ input, output });
+        identifier = (await rl.question(tr('Email или username: ', 'Email or username: '))).trim();
+        rl.close();
+    }
+    if (!identifier)
+        throw new Error(tr('Нужен email или username', 'Email or username is required'));
+    const password = await readPassword(tr('Пароль: ', 'Password: '));
+    if (!password)
+        throw new Error(tr('Нужен пароль', 'Password is required'));
+    const data = await api(server, null, 'POST', '/api/auth/login', { identifier, password });
+    const cfg = loadConfig();
+    cfg.server = server;
+    cfg.token = data.token;
+    saveConfig(cfg);
+    console.log(tr(`Вошли на ${server}. Токен сохранён в ${CONFIG_PATH}.`, `Signed in to ${server}. Token saved to ${CONFIG_PATH}.`));
+    const me = await api(server, data.token, 'GET', '/api/users/me');
+    applyAccentFromMe(me);
+    console.log(tr(`Пользователь: ${me.name} <${me.email}>${me.isPro ? ' [PRO]' : ''}`, `User: ${me.name} <${me.email}>${me.isPro ? ' [PRO]' : ''}`));
+}
+/**
+ * Вход через браузер (device-flow): терминал показывает ссылку, человек
+ * подтверждает на странице /cli-login (там же входит в мессенджер, если
+ * нужно), терминал забирает обычный токен пользователя polling'ом.
+ */
+async function startDeviceFlow(server) {
+    const challenge = await api(server, null, 'POST', '/api/cli/device');
+    console.log(tr('\nДля входа откройте в браузере:', '\nOpen this link in your browser to sign in:'));
+    console.log(`  ${challenge.verification_url}`);
+    console.log(tr(`Код должен совпасть с терминалом: ${challenge.user_code}`, `The code must match the terminal: ${challenge.user_code}`));
+    try {
+        await openWithDefaultApp(challenge.verification_url);
+    }
+    catch { /* нет GUI — ссылку уже показали */ }
+    console.log(tr('Ожидаю подтверждения в браузере… (Ctrl+C — отмена)', 'Waiting for browser confirmation… (Ctrl+C — cancel)'));
+    const deadline = Date.now() + challenge.expires_in * 1000;
+    const intervalMs = Math.max(1000, (challenge.poll_interval || 3) * 1000);
+    for (;;) {
+        await new Promise(r => setTimeout(r, intervalMs));
+        const poll = await api(server, null, 'GET', `/api/cli/device?device_code=${challenge.device_code}`).then((data) => ({ ok: true, data: data }), (err) => ({ ok: false, status: err.status }));
+        if (!poll.ok) {
+            if (poll.status === 410)
+                throw new Error(tr('Время вышло. Запустите surf заново.', 'Timed out. Start surf again.'));
+            throw new Error(tr('Не удалось связаться с сервером', 'Could not reach the server'));
+        }
+        const status = poll.data;
+        if (status.status === 'approved' && status.token) {
+            const cfg = loadConfig();
+            cfg.server = server;
+            cfg.token = status.token;
+            saveConfig(cfg);
+            const me = await api(server, status.token, 'GET', '/api/users/me');
+            applyAccentFromMe(me);
+            console.log(tr(`\nВошли как ${me.name} <${me.email}>${me.isPro ? ' [PRO]' : ''}.`, `\nSigned in as ${me.name} <${me.email}>${me.isPro ? ' [PRO]' : ''}.`));
+            return status.token;
+        }
+        if (Date.now() >= deadline)
+            throw new Error(tr('Время вышло. Запустите surf заново.', 'Timed out. Start surf again.'));
+    }
+}
+/**
+ * Гарантирует токен: проверяет сохранённый, иначе (в интерактивном терминале)
+ * предлагает войти через браузер. В скриптах без TTY — сразу ошибка.
+ */
+async function ensureToken(server) {
+    const saved = loadConfig().token;
+    if (saved) {
+        const check = await api(server, saved, 'GET', '/api/users/me').then((data) => ({ ok: true, data }), (err) => ({ ok: false, status: err.status }));
+        if (check.ok) {
+            applyAccentFromMe(check.data);
+            return saved;
+        }
+        if (check.status !== 401) {
+            throw new Error(tr('Не удалось связаться с сервером для проверки токена', 'Could not reach the server to verify the token'));
+        }
+        // Токен протух — идём на вход заново.
+    }
+    if (!process.stdin.isTTY) {
+        throw new Error(tr('Нет действующего токена. Выполните: surf login', 'No valid token. Run: surf login'));
+    }
+    const rl = readline.createInterface({ input, output });
+    const answer = (await rl.question(tr('Нажмите Enter для входа через браузер (Log in) или q для выхода: ', 'Press Enter to sign in through a browser, or q to exit: '))).trim().toLowerCase();
+    rl.close();
+    if (answer === 'q' || answer === 'й' || answer === 'n' || answer === 'т' || answer === 'нет' || answer === 'выход') {
+        throw new Error(tr('Вход отменён.', 'Sign-in cancelled.'));
+    }
+    return startDeviceFlow(server);
+}
+async function cmdToken(args) {
+    const server = resolveServer(getArgValue(args, '--server'));
+    const positional = args.filter(a => !a.startsWith('--'));
+    const jwt = positional[0];
+    if (!jwt)
+        throw new Error(tr('Использование: surf token <jwt> [--server URL]', 'Usage: surf token <jwt> [--server URL]'));
+    // Проверяем токен сразу, чтобы не сохранять битый.
+    const checked = await api(server, jwt, 'GET', '/api/users/me');
+    applyAccentFromMe(checked);
+    const cfg = loadConfig();
+    cfg.server = server;
+    cfg.token = jwt;
+    saveConfig(cfg);
+    console.log(tr(`Токен сохранён (${CONFIG_PATH}).`, `Token saved (${CONFIG_PATH}).`));
+}
+function cmdLogout() {
+    const cfg = loadConfig();
+    cfg.token = null;
+    cfg.accent = null;
+    saveConfig(cfg);
+    setAccentColor(null);
+    console.log(tr('Вышли: токен удалён.', 'Signed out: token removed.'));
+}
+async function cmdWhoami(args) {
+    const server = resolveServer(getArgValue(args, '--server'));
+    const token = await ensureToken(server);
+    const me = await api(server, token, 'GET', '/api/users/me');
+    applyAccentFromMe(me);
+    console.log(`${me.name} ${me.surname || ''} (@${me.username}, id ${me.id}, ${me.email})${me.isPro ? ' [PRO]' : ''}`);
+}
+async function cmdUsage(args) {
+    const server = resolveServer(getArgValue(args, '--server'));
+    const token = await ensureToken(server);
+    const u = await api(server, token, 'GET', '/api/ai/usage');
+    if (hasFlag(args, '--json'))
+        console.log(JSON.stringify(u, null, 2));
+    else
+        printUsage(u);
+}
+async function uploadAttachment(server, token, filePath) {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile())
+        throw new Error(tr(`Не файл: ${filePath}`, `Not a file: ${filePath}`));
+    if (stat.size > 25 * 1024 * 1024)
+        throw new Error(tr('Файл больше 25 МБ', 'File is larger than 25 MB'));
+    const buffer = fs.readFileSync(filePath);
+    const form = new FormData();
+    form.append('file', new Blob([buffer]), path.basename(filePath));
+    const res = await fetch(resolveUrl(server, '/api/upload/file'), {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}` },
+        body: form,
+    });
+    if (!res.ok)
+        throw new Error(tr(`Загрузка не удалась: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`, `Upload failed: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`));
+    const data = await res.json();
+    return { url: data.url, type: data.type, name: path.basename(filePath) };
+}
+/** Загрузка инлайн-вложений из строки (токены [image N]/[file N]). */
+async function uploadInlineAttachments(server, token, atts, live) {
+    const out = [];
+    for (const a of atts) {
+        if (!live.has(a.token))
+            continue;
+        try {
+            const up = await uploadAttachment(server, token, a.path);
+            out.push({ ...up, token: a.token });
+            console.log(`${paint(tr('Прикреплено:', 'Attached:'), 'green')} ${paint(up.name, 'white')}`);
+        }
+        catch (err) {
+            console.error(`${paint(tr('Не удалось прикрепить:', 'Could not attach:'), 'red')} ${a.path}: ${err.message}`);
+        }
+    }
+    return out;
+}
+async function postProcessStream(server, token, body, handlers, stream) {
+    const res = await fetch(resolveUrl(server, '/api/ai/process'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+        body: JSON.stringify(stream ? { ...body, stream: true } : body),
+    });
+    if (!res.ok) {
+        const payload = await res.json().catch(() => ({}));
+        const err = new Error(payload.error || `HTTP ${res.status}`);
+        err.status = res.status;
+        err.payload = payload;
+        throw err;
+    }
+    const contentType = res.headers.get('content-type') || '';
+    if (!stream || !contentType.includes('text/event-stream') || !res.body) {
+        return res.json();
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let carry = '';
+    let done = null;
+    const handleBlock = (block) => {
+        let event = 'message';
+        const lines = [];
+        for (const raw of block.split('\n')) {
+            const line = raw.replace(/\r$/, '');
+            if (line.startsWith('event:'))
+                event = line.slice(6).trim();
+            else if (line.startsWith('data:'))
+                lines.push(line.slice(5).trimStart());
+        }
+        if (!lines.length)
+            return;
+        const data = JSON.parse(lines.join('\n'));
+        if (event === 'delta' && data.text)
+            handlers.onDelta?.(data.text);
+        else if (event === 'status' && data.status)
+            handlers.onStatus?.(data.status);
+        else if (event === 'reset')
+            handlers.onReset?.();
+        else if (event === 'done')
+            done = data;
+        else if (event === 'error')
+            throw new Error(data.error || 'stream error');
+    };
+    for (;;) {
+        const { done: finished, value } = await reader.read();
+        if (finished)
+            break;
+        carry += decoder.decode(value, { stream: true });
+        const blocks = carry.split('\n\n');
+        carry = blocks.pop() || '';
+        for (const b of blocks)
+            handleBlock(b);
+    }
+    if (carry.trim())
+        handleBlock(carry);
+    if (!done)
+        throw new Error(tr('Стрим оборвался без done', 'The stream ended without done'));
+    return done;
+}
+function printRichPayload(payload, server) {
+    const webSearch = payload.webSearch;
+    if (webSearch?.sources?.length) {
+        console.log(`\n${paint(tr('— Источники веб-поиска:', '— Web search sources:'), 'accent')}`);
+        for (const s of webSearch.sources.slice(0, 8))
+            console.log(`  ${paint('•', 'accent')} ${s.title} — ${paint(s.url, 'blue')}`);
+    }
+    const images = payload.images;
+    if (images?.length) {
+        console.log(`\n${paint(tr('— Картинки:', '— Images:'), 'accent')}`);
+        for (const img of images)
+            console.log(`  ${paint('•', 'accent')} ${paint(resolveUrl(server, img.url), 'blue')}${img.alt ? paint(` (${img.alt})`, 'gray') : ''}`);
+    }
+    const attachments = payload.attachments;
+    if (attachments?.length) {
+        console.log(`\n${paint(tr('— Файлы:', '— Files:'), 'accent')}`);
+        for (const f of attachments)
+            console.log(`  ${paint('•', 'accent')} ${paint(f.name, 'white')}: ${paint(resolveUrl(server, f.url), 'blue')}`);
+        console.log(paint(tr('Скачать: surf get <url> [--open]', 'Download: surf get <url> [--open]'), 'gray'));
+    }
+    if (payload.map)
+        console.log(`\n${paint(tr('— К ответу приложена интерактивная карта (смотри в мессенджере).', '— An interactive map is attached to the reply (view it in the messenger).'), 'gray')}`);
+}
+function handleProcessError(err) {
+    const e = err;
+    if (e?.status === 429 && e.payload?.code === 'ai_token_limit') {
+        console.error(`\n${paint(tr('Лимит Opus исчерпан (общий с мессенджером).', 'The Opus limit is exhausted (shared with the messenger).'), 'red')}`);
+        const usage = e.payload?.usage;
+        if (usage)
+            console.error(usageCard(usage));
+        process.exitCode = 2;
+        return;
+    }
+    if (e?.status === 401) {
+        console.error(tr('Не авторизован: токен протух. Выполни: surf login', 'Unauthorized: the token expired. Run: surf login'));
+        process.exitCode = 1;
+        return;
+    }
+    console.error(tr(`Ошибка: ${e?.message || err}`, `Error: ${e?.message || err}`));
+    process.exitCode = 1;
+}
+/** Красивое имя: opus-file-<uuid>__Отчёт.xlsx → Отчёт.xlsx */
+function prettyFileName(urlPath) {
+    const base = path.basename(urlPath.split('?')[0]) || 'file';
+    if (base.startsWith('opus-file-')) {
+        const sep = base.indexOf('__');
+        if (sep !== -1 && sep + 2 < base.length)
+            return base.slice(sep + 2);
+    }
+    return base;
+}
+function fileNameFromDisposition(header, fallback) {
+    if (!header)
+        return fallback;
+    const star = header.match(/filename\*\s*=\s*UTF-8''([^;]+)/i);
+    if (star) {
+        try {
+            return decodeURIComponent(star[1].trim().replace(/["']/g, ''));
+        }
+        catch { /* fallback ниже */ }
+    }
+    const plain = header.match(/filename\s*=\s*"?([^";]+)"?/i);
+    if (plain)
+        return plain[1].trim();
+    return fallback;
+}
+async function openWithDefaultApp(target) {
+    const { spawn } = await import('node:child_process');
+    // URL открываем как есть. path.resolve() — только для файлов: иначе
+    // http://... превращается в «C:\...\http://…» (см. диалог Windows).
+    const abs = /^https?:\/\//i.test(target) ? target : path.resolve(target);
+    // На Windows вся команда — одна /c-строка с явным title: пустой title
+    // отдельным argv ненадёжен, и start принимает URL за имя программы —
+    // Windows ищет «C:\...\http://…» вместо открытия браузера.
+    const child = process.platform === 'win32'
+        ? spawn('cmd.exe', ['/d', '/s', '/c', `start "" "${abs}"`], { detached: true, stdio: 'ignore', windowsHide: true })
+        : process.platform === 'darwin'
+            ? spawn('open', [abs], { detached: true, stdio: 'ignore' })
+            : spawn('xdg-open', [abs], { detached: true, stdio: 'ignore' });
+    // Fire-and-forget: ссылку уже напечатали, fallback — открыть вручную.
+    child.on('error', () => { });
+    child.unref();
+}
+/**
+ * Скачивание вложений Opus. /uploads отдают файлы только авторизованным
+ * (Bearer-токен того же пользователя), поэтому обычная вставка ссылки
+ * в браузер без сессии мессенджера не сработает — качаем с токеном.
+ */
+async function cmdGet(args) {
+    const server = resolveServer(getArgValue(args, '--server'));
+    const token = await ensureToken(server);
+    const outArg = getArgValue(args, '--out', '-o');
+    const open = hasFlag(args, '--open');
+    const skip = new Set(['--server', '--out', '-o']);
+    const urls = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (skip.has(a)) {
+            i += 1;
+            continue;
+        }
+        if (a.startsWith('--'))
+            continue;
+        urls.push(a);
+    }
+    if (!urls.length)
+        throw new Error('Использование: surf get <url|/uploads/...> [--out путь] [--open]');
+    for (const raw of urls) {
+        const url = resolveUrl(server, raw);
+        const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+        if (!res.ok) {
+            console.error(`Не удалось скачать ${raw}: HTTP ${res.status}`);
+            process.exitCode = 1;
+            continue;
+        }
+        const urlPath = new URL(url).pathname;
+        const name = fileNameFromDisposition(res.headers.get('content-disposition'), prettyFileName(urlPath));
+        let dest = outArg || path.join(process.cwd(), name);
+        try {
+            const stat = fs.existsSync(dest) ? fs.statSync(dest) : null;
+            if (stat?.isDirectory() || (!stat && !path.extname(dest))) {
+                dest = path.join(dest, name);
+            }
+        }
+        catch {
+            dest = path.join(process.cwd(), name);
+        }
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        const buffer = Buffer.from(await res.arrayBuffer());
+        fs.writeFileSync(dest, buffer);
+        console.log(`Сохранено: ${dest} (${buffer.length} байт)`);
+        if (open) {
+            await openWithDefaultApp(dest);
+            console.log(`Открыто: ${dest}`);
+        }
+    }
+}
+/**
+ * Общий цикл ответа: спиннер мышления со статусами → заголовок Opus →
+ * построчный markdown-стрим. Спиннер пишет в stderr, ответ — в stdout.
+ */
+async function streamAnswer(server, token, body, model, showHead) {
+    const spinner = new Spinner();
+    const md = new MdStream();
+    let headed = false;
+    const ensureHead = () => {
+        if (headed)
+            return;
+        headed = true;
+        spinner.stop();
+        if (showHead)
+            process.stdout.write(`${assistantHead(modelDisplayName(model))}\n`);
+    };
+    try {
+        const payload = await postProcessStream(server, token, body, {
+            onStatus: s => {
+                if (!headed)
+                    spinner.start(statusLabel(s));
+                spinner.update(statusLabel(s));
+            },
+            onDelta: t => {
+                ensureHead();
+                process.stdout.write(md.push(t));
+            },
+        }, true);
+        ensureHead();
+        const tail = md.flush();
+        if (tail)
+            process.stdout.write(tail);
+        process.stdout.write('\n');
+        return payload;
+    }
+    finally {
+        spinner.stop();
+    }
+}
+async function cmdAsk(args) {
+    const server = resolveServer(getArgValue(args, '--server'));
+    const token = await ensureToken(server);
+    const model = resolveModel(getArgValue(args, '--model', '-m'));
+    const stream = !hasFlag(args, '--no-stream');
+    const json = hasFlag(args, '--json');
+    const chatIdRaw = getArgValue(args, '--chat-id');
+    const chatId = chatIdRaw ? Number(chatIdRaw) : undefined;
+    const attachPath = getArgValue(args, '--attach', '--file', '-f');
+    // Простой сбор текста: всё после 'ask', кроме значений известных флагов.
+    const skip = new Set(['--model', '-m', '--attach', '--file', '-f', '--chat-id', '--server']);
+    const words = [];
+    const rest = args;
+    for (let i = 0; i < rest.length; i += 1) {
+        const a = rest[i];
+        if (skip.has(a)) {
+            i += 1;
+            continue;
+        }
+        if (a.startsWith('--'))
+            continue;
+        words.push(a);
+    }
+    const text = words.join(' ').trim();
+    if (!text && !attachPath)
+        throw new Error('Использование: surf ask <текст> [--model auto] [--attach файл]');
+    const attachments = attachPath ? [await uploadAttachment(server, token, attachPath)] : undefined;
+    try {
+        if (stream && !json) {
+            const payload = await streamAnswer(server, token, { text: text || 'Опиши прикреплённое.', history: [], model, ...(chatId ? { chatId } : {}), ...(attachments ? { attachments } : {}) }, model, false);
+            printRichPayload(payload, server);
+        }
+        else {
+            const payload = await postProcessStream(server, token, { text: text || 'Опиши прикреплённое.', history: [], model, ...(chatId ? { chatId } : {}), ...(attachments ? { attachments } : {}) }, {}, false);
+            if (json) {
+                console.log(JSON.stringify(payload, null, 2));
+                return;
+            }
+            const md = new MdStream();
+            process.stdout.write(md.push(String(payload.response || '')) + md.flush() + '\n');
+            printRichPayload(payload, server);
+        }
+        const u = await api(server, token, 'GET', '/api/ai/usage').catch(() => null);
+        if (u && !json)
+            console.error(`\n${answerFooter(modelDisplayName(model), u)}`);
+    }
+    catch (err) {
+        handleProcessError(err);
+    }
+}
+async function cmdChat(args) {
+    const server = resolveServer(getArgValue(args, '--server'));
+    const token = await ensureToken(server);
+    let model = resolveModel(getArgValue(args, '--model', '-m'));
+    const chatIdRaw = getArgValue(args, '--chat-id');
+    const chatId = chatIdRaw ? Number(chatIdRaw) : undefined;
+    const history = [];
+    let pendingAttachments;
+    // Агентные задачи с файлами — инлайн, в том же чате: свой контекст
+    // инструментов и своя история диалогов с моделью-агентом.
+    // Заодно создаём папку пользовательских скиллов, если её нет.
+    ensureUserSkillsDir();
+    let permissionMode = loadConfig().permissionMode;
+    const codeCtx = createToolContext(process.cwd(), hasFlag(args, '--yes', '-y'), permissionMode);
+    const agentHistory = [{ role: 'system', content: CODE_SYSTEM(codeCtx.cwd, process.platform) }];
+    console.log(chatBanner({
+        version: VERSION,
+        model: modelDisplayName(model) + (model === 'auto' ? tr(' (сама подбирает)', ' (chooses automatically)') : ''),
+        usage: await api(server, token, 'GET', '/api/ai/usage').catch(() => null),
+    }));
+    // Один интерфейс на весь чат + вечная очередь строк: readline роняет
+    // 'line', пришедшие без слушателя (pipe, вставки), поэтому копим всё.
+    // Для стрелочного пикера интерфейс закрываем и создаём заново (см. /model).
+    const interactive = !!process.stdin.isTTY && !!process.stdout.isTTY;
+    const chatHistory = loadHistory();
+    let rl = interactive ? null : readline.createInterface({ input, output, completer, prompt: paint('› ', 'accent') });
+    // pipe сам закрывает интерфейс по EOF раньше, чем кончается очередь.
+    let rlClosed = false;
+    const lineQueue = [];
+    let lineWaiter = null;
+    const wireRl = (r) => {
+        r.on('line', (l) => {
+            if (lineWaiter) {
+                const w = lineWaiter;
+                lineWaiter = null;
+                w(l);
+            }
+            else {
+                lineQueue.push(l);
+            }
+        });
+        r.on('close', () => {
+            rlClosed = true;
+            if (lineWaiter) {
+                const w = lineWaiter;
+                lineWaiter = null;
+                w(null);
+            }
+        });
+    };
+    if (rl)
+        wireRl(rl);
+    const nextLine = () => {
+        const queued = lineQueue.shift();
+        if (queued !== undefined)
+            return Promise.resolve(queued);
+        // Интерфейс мёртв и очередь пуста — дальше строк не будет.
+        if (rlClosed)
+            return Promise.resolve(null);
+        return new Promise(resolve => {
+            lineWaiter = resolve;
+        });
+    };
+    if (rl)
+        rl.prompt();
+    const rep = () => {
+        if (!rl || rlClosed)
+            return;
+        try {
+            rl.prompt();
+        }
+        catch {
+            rlClosed = true;
+        }
+    };
+    for (;;) {
+        const submitted = interactive
+            ? await promptMenuLine({ prompt: paint('› ', 'accent'), history: chatHistory, complete: completeChatLine, noArgCommands: CHAT_NO_ARG_COMMANDS })
+            : { line: await nextLine(), attachments: [] };
+        if (submitted.line === null)
+            break;
+        if (interactive && submitted.line.trim()) {
+            chatHistory.push(submitted.line.trim());
+            if (chatHistory.length > 200)
+                chatHistory.shift();
+            appendHistory(submitted.line);
+        }
+        // Загружаем только вложения, чьи токены остались в строке
+        // (стёртые Backspace из текста не отправляем).
+        const liveTokens = new Set((submitted.line.match(/\[(image|file) \d+\]/g) ?? [])
+            .filter(t => submitted.attachments.some(a => a.token === t)));
+        const inlineUploads = liveTokens.size > 0
+            ? await uploadInlineAttachments(server, token, submitted.attachments, liveTokens)
+            : [];
+        pendingAttachments = [...(pendingAttachments || []), ...inlineUploads];
+        // Токены загруженных файлов вычищаем из текста.
+        let msg = submitted.line.trim();
+        if (inlineUploads.length > 0) {
+            for (const u of inlineUploads)
+                msg = msg.split(u.token).join('');
+            msg = msg.replace(/\s+/g, ' ').trim();
+        }
+        if (!msg) {
+            if (inlineUploads.length > 0)
+                console.log(paint(tr('(файлы прикреплены — напишите сообщение)', '(files attached — write a message)'), 'gray'));
+            rep();
+            continue;
+        }
+        if (msg === '/exit' || msg === '/quit')
+            break;
+        if (msg === '/logout') {
+            cmdLogout();
+            break;
+        }
+        if (msg === '/clear') {
+            history.length = 0;
+            agentHistory.length = 0;
+            agentHistory.push({ role: 'system', content: CODE_SYSTEM(codeCtx.cwd, process.platform) });
+            console.log(paint(tr('(история очищена)', '(history cleared)'), 'gray'));
+            rep();
+            continue;
+        }
+        if (msg === '/help') {
+            console.log(chatHelp());
+            rep();
+            continue;
+        }
+        if (msg === '/permissions') {
+            const res = await pickPermissionMode(permissionMode, () => nextLine());
+            if (res && res !== 'arrows') {
+                permissionMode = res;
+                codeCtx.permissionMode = res;
+                savePermissionMode(res);
+                console.log(`${paint(tr('Разрешения:', 'Permissions:'), 'gray')} ${paint(permissionModeLabel(res), 'white')}`);
+                rep();
+                continue;
+            }
+            if (res === null) {
+                rep();
+                continue;
+            }
+            const idx = await selectArrows(tr('Разрешения для coding-агента (↑↓ выбор, Enter — ok, Esc — отмена):', 'Coding-agent permissions (↑↓ choose, Enter — confirm, Esc — cancel):'), permissionOptions(permissionMode));
+            if (idx !== null) {
+                permissionMode = PERMISSION_OPTION_IDS[idx];
+                codeCtx.permissionMode = permissionMode;
+                savePermissionMode(permissionMode);
+                console.log(`${paint(tr('Разрешения:', 'Permissions:'), 'gray')} ${paint(permissionModeLabel(permissionMode), 'white')}`);
+            }
+            rep();
+            continue;
+        }
+        if (msg === '/skills') {
+            printSkills(codeCtx.cwd);
+            rep();
+            continue;
+        }
+        if (msg === '/usage') {
+            try {
+                printUsage(await api(server, token, 'GET', '/api/ai/usage'));
+            }
+            catch (err) {
+                handleProcessError(err);
+            }
+            rep();
+            continue;
+        }
+        if (msg === '/model' || msg.startsWith('/model ')) {
+            const res = await pickModel(msg, model, () => nextLine());
+            if (res && res !== 'arrows') {
+                model = res;
+                saveModel(model);
+                console.log(confirmModelLine(model));
+                rep();
+                continue;
+            }
+            if (res === null) {
+                rep();
+                continue;
+            }
+            // Стрелочный пикер требует голый stdin: закрываем интерфейс,
+            // выбираем, создаём заново.
+            if (rl)
+                rl.close();
+            const options = modelOptions(msg, model);
+            const idx = await selectArrows(tr('Модель — общий лимит для всех (↑↓ выбор, Enter — ok, Esc — отмена):', 'Model — shared limit for all (↑↓ choose, Enter — confirm, Esc — cancel):'), options);
+            if (!interactive) {
+                rl = readline.createInterface({ input, output, completer, prompt: paint('› ', 'accent') });
+                wireRl(rl);
+            }
+            rlClosed = false;
+            if (idx !== null) {
+                model = normalizeOpusModelId(options[idx].id);
+                saveModel(model);
+                console.log(confirmModelLine(model));
+            }
+            rep();
+            continue;
+        }
+        if (msg.startsWith('/')) {
+            // Вызов скилла как slash-команды: /имя-скилла [текст задачи]
+            const skillName = msg.slice(1).split(/\s+/)[0]?.toLowerCase() ?? '';
+            const skillArgs = msg.slice(1 + skillName.length).trim();
+            const skill = skillName ? loadSkill(codeCtx.cwd, skillName) : null;
+            if (skill) {
+                const taskText = skillArgs || tr('Следуй инструкциям навыка.', 'Follow the skill instructions.');
+                console.log(paint(tr(`— навык ${skill.meta.name}: работаю…`, `— skill ${skill.meta.name}: working…`), 'gray'));
+                const skillTask = `<skill name="${skill.meta.name}">\n${skill.instructions}\n</skill>\n\n${tr('Задача пользователя:', 'User task:')} ${taskText}`;
+                const lastText = await runAgentTask(server, token, model, codeCtx, agentHistory, skillTask, 25);
+                history.push({ role: 'user', text: msg });
+                history.push({ role: 'ai', text: lastText.slice(0, 1500) || '(задача выполнена)' });
+                rep();
+                continue;
+            }
+            console.log(paint(tr('Неизвестная команда. /help — список.', 'Unknown command. /help lists commands.'), 'gray'));
+            rep();
+            continue;
+        }
+        // Один режим на всё: похоже на задачу с файлами/кодом — агентный цикл
+        // с инструментами прямо здесь; «!» в начале форсирует. Вложенные файлы
+        // всегда идут обычным чатом.
+        const forceAgent = msg.startsWith('!');
+        if ((forceAgent || looksLikeCodeTask(msg)) && !pendingAttachments?.length) {
+            const taskText = (forceAgent ? msg.slice(1) : msg).trim();
+            if (!taskText) {
+                rep();
+                continue;
+            }
+            console.log(paint(tr('— агент: работаю с файлами…', '— agent: working with files…'), 'gray'));
+            const lastText = await runAgentTask(server, token, model, codeCtx, agentHistory, taskText, 25);
+            history.push({ role: 'user', text: msg });
+            history.push({ role: 'ai', text: lastText.slice(0, 1500) || '(задача выполнена)' });
+            rep();
+            continue;
+        }
+        const attachments = pendingAttachments;
+        pendingAttachments = undefined;
+        try {
+            const payload = await streamAnswer(server, token, { text: msg, history: history.slice(-10), model, ...(chatId ? { chatId } : {}), ...(attachments?.length ? { attachments } : {}) }, model, true);
+            printRichPayload(payload, server);
+            history.push({ role: 'user', text: msg });
+            history.push({ role: 'ai', text: String(payload.response || '') });
+            const u = await api(server, token, 'GET', '/api/ai/usage').catch(() => null);
+            const footer = answerFooter(modelDisplayName(model), u);
+            if (footer)
+                console.log(footer);
+        }
+        catch (err) {
+            handleProcessError(err);
+            if (err.status === 429)
+                break;
+        }
+        rep();
+    }
+    if (rl)
+        rl.close();
+    console.log(paint(tr('Пока!', 'Bye!'), 'accent'));
+}
+/** Пул моделей для пикера: фильтр по префиксу/подстроке или весь список без auto. */
+function modelPool(msg) {
+    const key = normModelKey(msg.slice('/model'.length).trim());
+    const pool = key
+        ? PICKABLE_MODEL_IDS.filter(id => id.startsWith(key) || id.includes(key))
+        : PICKABLE_MODEL_IDS;
+    if (key && pool.length === 0) {
+        console.log(paint(tr(`Модель «${key}» не найдена. Выберите из списка:`, `Model “${key}” was not found. Choose from the list:`), 'yellow'));
+    }
+    return pool.length > 0 ? pool : PICKABLE_MODEL_IDS;
+}
+function modelOptions(msg, current) {
+    const pool = modelPool(msg);
+    // Auto/fast/advanced обычно скрыты из ручного списка. Но если один из них
+    // уже выбран, он должен быть отмечен текущим: иначе Enter в пикере молча
+    // применяет первый видимый вариант (сейчас это GPT-5.6 Sol).
+    const ids = !msg.slice('/model'.length).trim() && OPUS_MODEL_IDS.includes(current) && !pool.includes(current)
+        ? [current, ...pool]
+        : pool;
+    return ids.map(id => ({
+        id,
+        label: modelDisplayName(id),
+        current: id === current,
+    }));
+}
+import { promptMenuLine, loadHistory, appendHistory, completeChatLine, CHAT_NO_ARG_COMMANDS, looksLikeCodeTask, } from './cliPrompt.js';
+import { CODE_TOOLS, createToolContext, executeAgentTool, } from './cliTools.js';
+import { skillsCatalog, loadSkill, discoverSkills, ensureUserSkillsDir, } from './cliSkills.js';
+/** Печать установленных скиллов: имя, источник, описание. */
+function printSkills(cwd) {
+    const { skills, invalid } = discoverSkills(cwd);
+    if (skills.length === 0) {
+        console.log(paint(tr('Навыков нет. Положи SKILL.md в .surf/skills/<имя>/ (проект) или ~/.surf-cli/skills/<имя>/', 'No skills found. Put SKILL.md in .surf/skills/<name>/ (project) or ~/.surf-cli/skills/<name>/.'), 'gray'));
+        return;
+    }
+    console.log(paint(tr('Навыки агента (модель подхватывает сама, /имя — вызвать):', 'Agent skills (the model can use them automatically; /name runs one):'), 'gray'));
+    for (const s of skills) {
+        console.log(`  ${paint(s.name, 'white')}${paint(` [${s.source}]`, 'gray')} — ${s.description}`);
+    }
+    if (invalid > 0)
+        console.log(paint(tr(`Пропущено битых: ${invalid} (нужны name/description в SKILL.md)`, `Skipped invalid: ${invalid} (SKILL.md needs name and description)`), 'yellow'));
+}
+/** Строка подтверждения выбора: «Модель: GPT-5 Mini». */
+function confirmModelLine(model) {
+    return `${paint(tr('Модель:', 'Model:'), 'gray')} ${paint(modelDisplayName(model), 'white')}`;
+}
+/**
+ * Какая модель стартует: явный флаг --model, иначе запомненная в прошлый
+ * раз (/model пишет её в конфиг), иначе auto. Удалённые с бэка id
+ * отваливаются обратно в auto.
+ */
+function resolveModel(flagValue) {
+    if (flagValue)
+        return normalizeOpusModelId(normModelKey(flagValue));
+    const saved = loadConfig().model;
+    if (saved && OPUS_MODEL_IDS.includes(saved))
+        return normalizeOpusModelId(saved);
+    return 'auto';
+}
+/** Запомнить выбор из /model для следующих запусков. */
+function saveModel(model) {
+    const cfg = loadConfig();
+    if (cfg.model === model)
+        return;
+    cfg.model = model;
+    saveConfig(cfg);
+}
+const PERMISSION_OPTION_IDS = ['always', 'important', 'never'];
+function permissionOption(mode) {
+    if (mode === 'always')
+        return { id: mode, label: tr('Всегда спрашивать', 'Always ask'), hint: tr('подтверждать каждую правку и команду', 'confirm every edit and command') };
+    if (mode === 'never')
+        return { id: mode, label: tr('Не спрашивать', 'Never ask'), hint: tr('выполнять действия без подтверждений', 'run actions without confirmations') };
+    return { id: mode, label: tr('Только важные действия', 'Important actions only'), hint: tr('обычные правки и проверки без вопроса', 'routine edits and checks without a prompt') };
+}
+function permissionModeLabel(mode) {
+    return permissionOption(mode).label;
+}
+function savePermissionMode(mode) {
+    const cfg = loadConfig();
+    if (cfg.permissionMode === mode)
+        return;
+    cfg.permissionMode = mode;
+    saveConfig(cfg);
+}
+function permissionOptions(current) {
+    return PERMISSION_OPTION_IDS.map(id => {
+        const option = permissionOption(id);
+        return { ...option, current: id === current };
+    });
+}
+async function pickPermissionMode(current, readLine) {
+    if (canUseArrows())
+        return 'arrows';
+    const index = await selectNumbered(tr('Разрешения для coding-агента:', 'Coding-agent permissions:'), permissionOptions(current), readLine);
+    return index === null ? null : PERMISSION_OPTION_IDS[index];
+}
+/**
+ * Выбор модели без стрелок: точный id и однозначный префикс — сразу,
+ * иначе пронумерованный список через живой rl чата.
+ * Возвращает id, null (отмена) или 'arrows' (нужен стрелочный пикер).
+ */
+async function pickModel(msg, current, readLine) {
+    const key = normModelKey(msg.slice('/model'.length).trim());
+    if (key && OPUS_MODEL_IDS.includes(key))
+        return normalizeOpusModelId(key);
+    const pool = key ? PICKABLE_MODEL_IDS.filter(id => id.startsWith(key) || id.includes(key)) : PICKABLE_MODEL_IDS;
+    if (key && pool.length === 1)
+        return normalizeOpusModelId(pool[0]);
+    if (canUseArrows())
+        return 'arrows';
+    const options = modelOptions(msg, current);
+    const idx = await selectNumbered(tr('Модель — общий лимит для всех:', 'Model — shared limit for all:'), options, readLine);
+    if (idx === null)
+        return null;
+    return normalizeOpusModelId(options[idx].id);
+}
+const CODE_SYSTEM = (cwd, platform) => `You are Surf Code, an AI coding assistant running in the user's terminal.
+Working directory: ${cwd} (platform ${platform}). ALL file tools are jailed here — refuse paths outside it.
+You have tools: read (file or directory listing), glob (find files), grep (search code), edit (exact string replacement, the file MUST be read first), write (create/overwrite file), bash (shell commands). The local CLI applies the user's permission mode before mutating tools run.
+Rules:
+- Always answer in Russian. Be concise: say what you did and how to verify, skip the play-by-play.
+- If the user asks about files, code or the project: ALWAYS call read/glob/grep first. Never describe, list or guess file contents you have not read with tools in THIS session. An answer about files without tool calls is a failure.
+- Explore with read/glob/grep before changing anything. Prefer small exact edits over rewrites.
+- Verify code changes with the project's own scripts (package.json scripts, tests, build, lint).
+- Never commit, push, publish or delete user data unless explicitly asked. Never create files unless needed for the task.
+- If the task is unclear or destructive, ask first instead of guessing.
+- Work until done or blocked; on blockers, clearly report what is missing.`;
+async function agentTurn(server, token, model, messages) {
+    const data = await api(server, token, 'POST', '/api/cli/agent', { model, messages, tools: CODE_TOOLS });
+    return { message: data.message, usage: data.usage };
+}
+function trimAgentHistory(history) {
+    // system всегда первый; остальное — скользящее окно.
+    while (history.length > 41) {
+        const idx = history.findIndex((m, i) => i > 0 && m.role !== 'system');
+        if (idx < 0)
+            break;
+        history.splice(idx, 1);
+    }
+}
+async function runAgentTask(server, token, model, ctx, history, userText, maxIters) {
+    history.push({ role: 'user', content: userText });
+    trimAgentHistory(history);
+    let emptyStreak = 0;
+    let lastText = '';
+    const skills = skillsCatalog(ctx.cwd);
+    const systemWithSkills = CODE_SYSTEM(ctx.cwd, process.platform) + (skills
+        ? `\n\nУстановленные Agent Skills (модульные возможности):\n${skills}\n\nЕсли задача подходит под описание навыка — СНАЧАЛА вызови инструмент skill (action=read, name=<имя>) и строго следуй его инструкциям, включая запуск приложенных скриптов через bash. Актуальный список — через skill action=list.`
+        : '');
+    if (history[0]?.role === 'system')
+        history[0] = { role: 'system', content: systemWithSkills };
+    else
+        history.unshift({ role: 'system', content: systemWithSkills });
+    for (let iter = 1; iter <= maxIters; iter += 1) {
+        const spinner = new Spinner();
+        spinner.start(tr('Думаю…', 'Thinking…'));
+        let turn;
+        try {
+            turn = await agentTurn(server, token, model, history);
+        }
+        catch (err) {
+            spinner.stop();
+            handleProcessError(err);
+            return lastText;
+        }
+        spinner.stop();
+        const msg = turn.message;
+        history.push({
+            role: 'assistant',
+            content: msg.content || '',
+            ...(msg.tool_calls?.length ? { tool_calls: msg.tool_calls } : {}),
+        });
+        if (msg.content) {
+            lastText = msg.content;
+            const md = new MdStream();
+            process.stdout.write(`${assistantHead(modelDisplayName(model))}\n`);
+            process.stdout.write(md.push(msg.content) + md.flush() + '\n');
+        }
+        const calls = msg.tool_calls ?? [];
+        if (calls.length === 0) {
+            if (!msg.content) {
+                // Пустой ход без инструментов: подтолкнуть один раз, иначе стоп.
+                emptyStreak += 1;
+                if (emptyStreak >= 2) {
+                    console.log(paint(tr('(модель не отвечает по делу — останавливаю)', '(the model is not progressing — stopping)'), 'yellow'));
+                    break;
+                }
+                history.push({ role: 'user', content: 'Продолжай задачу только с помощью инструментов: прочитай нужные файлы.' });
+                continue;
+            }
+            break;
+        }
+        emptyStreak = 0;
+        for (const call of calls) {
+            const rawArgs = call.function.arguments;
+            const argsPreview = rawArgs.length > 200 ? `${rawArgs.slice(0, 200)}…` : rawArgs;
+            console.log(`  ${paint('tool', 'gray')} ${paint(call.function.name, 'white')} ${paint(argsPreview, 'gray')}`);
+            const result = await executeAgentTool(ctx, { id: call.id, name: call.function.name, argsJson: rawArgs });
+            if (result.startsWith('ошибка') || result.startsWith('отклонено')) {
+                console.log(`  ${paint(result.split('\n')[0] ?? result, 'yellow')}`);
+            }
+            history.push({ role: 'tool', tool_call_id: call.id, content: result });
+        }
+        trimAgentHistory(history);
+    }
+    return lastText;
+}
+async function main() {
+    const [, , cmd, ...args] = process.argv;
+    loadSavedAccent();
+    try {
+        if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
+            printHelp();
+            return;
+        }
+        if (!cmd) {
+            // Просто `surf`: если не залогинен — предложим вход через браузер,
+            // затем сразу откроем чат.
+            await cmdChat(args);
+            return;
+        }
+        if (cmd === '--version' || cmd === 'version') {
+            console.log(VERSION);
+            return;
+        }
+        if (cmd === 'login') {
+            await cmdLogin(args);
+            return;
+        }
+        if (cmd === 'token') {
+            await cmdToken(args);
+            return;
+        }
+        if (cmd === 'logout') {
+            cmdLogout();
+            return;
+        }
+        if (cmd === 'whoami') {
+            await cmdWhoami(args);
+            return;
+        }
+        if (cmd === 'usage' || cmd === 'limits') {
+            await cmdUsage(args);
+            return;
+        }
+        if (cmd === 'models') {
+            printModels();
+            return;
+        }
+        if (cmd === 'ask') {
+            await cmdAsk(args);
+            return;
+        }
+        if (cmd === 'chat') {
+            await cmdChat(args);
+            return;
+        }
+        if (cmd === 'get' || cmd === 'download') {
+            await cmdGet(args);
+            return;
+        }
+        console.error(tr(`Неизвестная команда: ${cmd}\n`, `Unknown command: ${cmd}\n`));
+        printHelp();
+        process.exitCode = 1;
+    }
+    catch (err) {
+        console.error(tr(`Ошибка: ${err.message}`, `Error: ${err.message}`));
+        process.exitCode = 1;
+    }
+}
+void main();
+//# sourceMappingURL=cli.js.map