@deploya-app/cli 0.1.0

package/README.md

@@ -0,0 +1,18 @@
+# Deploya CLI
+
+Deploy static HTML/CSS/JavaScript sites to Deploya from a terminal, CI pipeline, or AI coding agent.
+
+```bash
+npx @deploya-app/cli login
+npx @deploya-app/cli deploy --dir dist --prod
+```
+
+The first production deploy creates a project and writes its non-secret ID to `.deploya/project.json`. Later deploys from the same directory update that project. Authentication tokens are stored in the user's configuration directory, never inside the project.
+
+For CI:
+
+```bash
+DEPLOYA_TOKEN=dpl_live_... npx @deploya-app/cli deploy --dir dist --prod
+```
+
+Full documentation: <https://docs.deploya.ru/cli>

package/bin/deploya.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+'use strict';
+
+const { run } = require('../src/cli');
+
+run(process.argv.slice(2)).catch((error) => {
+  const message = error?.message || String(error);
+  process.stderr.write(`Ошибка: ${message}\n`);
+  if (error?.hint) process.stderr.write(`${error.hint}\n`);
+  process.exitCode = Number(error?.exitCode || 1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@deploya-app/cli",
+  "version": "0.1.0",
+  "description": "Deploy static sites to Deploya from a terminal or AI agent",
+  "license": "MIT",
+  "bin": {
+    "deploya": "bin/deploya.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "deploya",
+    "deploy",
+    "static-site",
+    "hosting",
+    "cli",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bukhalov1/deploya.git",
+    "directory": "cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16"
+  }
+}

package/src/api.js

@@ -0,0 +1,47 @@
+'use strict';
+
+class ApiError extends Error {
+  constructor(message, status, code, details) {
+    super(message);
+    this.name = 'ApiError';
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+}
+
+async function parseResponse(response) {
+  const contentType = response.headers.get('content-type') || '';
+  const body = contentType.includes('json') ? await response.json().catch(() => ({})) : { message: await response.text().catch(() => '') };
+  if (!response.ok) {
+    const apiError = body?.error;
+    const message = typeof apiError === 'object' ? apiError.message : apiError || body.message || `HTTP ${response.status}`;
+    throw new ApiError(message, response.status, typeof apiError === 'object' ? apiError.code : 'HTTP_ERROR', apiError?.details);
+  }
+  return body;
+}
+
+async function request(apiBase, pathname, options = {}) {
+  const headers = { Accept: 'application/json', ...(options.headers || {}) };
+  if (options.token) headers.Authorization = `Bearer ${options.token}`;
+  let body = options.body;
+  if (body && !(body instanceof FormData)) {
+    headers['Content-Type'] = 'application/json';
+    body = JSON.stringify(body);
+  }
+  let response;
+  try {
+    response = await fetch(`${apiBase}${pathname}`, {
+      method: options.method || 'GET',
+      headers,
+      body,
+      signal: options.signal || AbortSignal.timeout(options.timeout || 30_000),
+    });
+  } catch (error) {
+    if (error?.name === 'TimeoutError' || error?.name === 'AbortError') throw new ApiError('Сервер Deploya не ответил вовремя.', 0, 'TIMEOUT');
+    throw new ApiError(`Не удалось подключиться к Deploya: ${error.message}`, 0, 'NETWORK_ERROR');
+  }
+  return parseResponse(response);
+}
+
+module.exports = { ApiError, request };

package/src/archive.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const AdmZip = require('adm-zip');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const HARD_DIRECTORIES = new Set(['.git', '.deploya', 'node_modules']);
+
+function loadIgnore(root) {
+  const rules = [];
+  for (const name of ['.gitignore', '.deployaignore']) {
+    const file = path.join(root, name);
+    if (!fs.existsSync(file)) continue;
+    for (const line of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
+      const value = line.trim();
+      if (!value || value.startsWith('#')) continue;
+      const negative = value.startsWith('!');
+      const pattern = (negative ? value.slice(1) : value).replace(/^\//, '');
+      if (pattern) rules.push({ negative, regex: globRegex(pattern) });
+    }
+  }
+  return {
+    ignores(relative, isDirectory) {
+      const normalized = relative.replace(/\\/g, '/').replace(/\/$/, '');
+      const segments = normalized.split('/');
+      const basename = segments.at(-1) || '';
+      if (segments.some((segment) => HARD_DIRECTORIES.has(segment))) return true;
+      if (basename === '.env' || (basename.startsWith('.env.') && basename !== '.env.example')) return true;
+      if (/\.(?:pem|key)$/i.test(basename)) return true;
+      let ignored = false;
+      for (const rule of rules) if (rule.regex.test(normalized) || (isDirectory && rule.regex.test(`${normalized}/`))) ignored = !rule.negative;
+      return ignored;
+    },
+  };
+}
+
+function globRegex(pattern) {
+  const directory = pattern.endsWith('/');
+  let source = pattern.replace(/\/$/, '').replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  source = source.replace(/\*\*/g, '§§').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]').replace(/§§/g, '.*');
+  const prefix = pattern.includes('/') ? '^' : '(^|.*/)';
+  return new RegExp(`${prefix}${source}${directory ? '(/.*)?' : ''}$`);
+}
+
+function collectFiles(root) {
+  const matcher = loadIgnore(root);
+  const files = [];
+  let bytes = 0;
+  function walk(directory) {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const absolute = path.join(directory, entry.name);
+      const relative = path.relative(root, absolute).split(path.sep).join('/');
+      if (entry.isSymbolicLink()) continue;
+      if (matcher.ignores(relative, entry.isDirectory())) continue;
+      if (entry.isDirectory()) walk(absolute);
+      else if (entry.isFile()) {
+        const stat = fs.statSync(absolute);
+        files.push({ absolute, relative, bytes: stat.size });
+        bytes += stat.size;
+      }
+    }
+  }
+  walk(root);
+  if (!files.length) throw new Error(`В папке ${root} нет файлов для деплоя.`);
+  if (files.length > 2000) throw new Error(`В проекте ${files.length} файлов. Лимит Deploya — 2000.`);
+  return { files, bytes };
+}
+
+function createArchive(root) {
+  const absoluteRoot = path.resolve(root);
+  if (!fs.existsSync(absoluteRoot) || !fs.statSync(absoluteRoot).isDirectory()) {
+    throw new Error(`Папка для деплоя не найдена: ${absoluteRoot}`);
+  }
+  const inventory = collectFiles(absoluteRoot);
+  const zip = new AdmZip();
+  for (const file of inventory.files) {
+    const zipDirectory = path.posix.dirname(file.relative);
+    zip.addLocalFile(file.absolute, zipDirectory === '.' ? '' : zipDirectory, path.posix.basename(file.relative));
+  }
+  const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'deploya-'));
+  const archivePath = path.join(temporaryDirectory, 'site.zip');
+  zip.writeZip(archivePath);
+  return {
+    archivePath,
+    bytes: inventory.bytes,
+    fileCount: inventory.files.length,
+    cleanup() { fs.rmSync(temporaryDirectory, { recursive: true, force: true }); },
+  };
+}
+
+module.exports = { collectFiles, createArchive };

package/src/auth.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const { request } = require('./api');
+const { saveSession } = require('./config');
+
+function openBrowser(url) {
+  let command;
+  let args;
+  if (process.platform === 'win32') { command = 'rundll32.exe'; args = ['url.dll,FileProtocolHandler', url]; }
+  else if (process.platform === 'darwin') { command = 'open'; args = [url]; }
+  else { command = 'xdg-open'; args = [url]; }
+  try {
+    const child = spawn(command, args, { detached: true, stdio: 'ignore', windowsHide: true });
+    child.unref();
+    return true;
+  } catch { return false; }
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function loginWithBrowser(apiBase, options = {}) {
+  const authorization = await request(apiBase, '/device/authorize', {
+    method: 'POST',
+    body: { clientName: options.clientName || `Deploya CLI on ${process.platform}` },
+  });
+  const output = options.output || process.stdout;
+  output.write(`Код подтверждения: ${authorization.userCode}\n`);
+  output.write(`Откройте: ${authorization.verificationUriComplete}\n`);
+  if (!options.noBrowser && openBrowser(authorization.verificationUriComplete)) output.write('Браузер открыт. Подтвердите доступ к аккаунту Deploya.\n');
+
+  const deadline = Date.now() + authorization.expiresIn * 1000;
+  while (Date.now() < deadline) {
+    await delay(Math.max(1, authorization.interval) * 1000);
+    try {
+      const result = await request(apiBase, '/device/token', { method: 'POST', body: { deviceCode: authorization.deviceCode } });
+      saveSession({ token: result.token, apiBase });
+      return result.user;
+    } catch (error) {
+      if (error.code === 'AUTHORIZATION_PENDING') continue;
+      throw error;
+    }
+  }
+  throw new Error('Время подтверждения истекло. Запустите deploya login ещё раз.');
+}
+
+module.exports = { loginWithBrowser, openBrowser };

package/src/cli.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const path = require('node:path');
+const { request } = require('./api');
+const { loginWithBrowser } = require('./auth');
+const { clearSession, loadProject, resolveCredentials, saveProject, saveSession } = require('./config');
+const { deployDirectory } = require('./deploy');
+
+const VERSION = '0.1.0';
+
+function parseArguments(argv) {
+  const positionals = [];
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (!value.startsWith('--')) { positionals.push(value); continue; }
+    const [rawName, inline] = value.slice(2).split(/=(.*)/s, 2);
+    const name = rawName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    if (inline !== undefined) options[name] = inline;
+    else if (argv[index + 1] && !argv[index + 1].startsWith('-')) options[name] = argv[++index];
+    else options[name] = true;
+  }
+  return { command: positionals[0] || 'help', positionals: positionals.slice(1), options };
+}
+
+function requireToken(credentials) {
+  if (credentials.token) return credentials.token;
+  const error = new Error('Вы не вошли в Deploya. Выполните: npx @deploya-app/cli login');
+  error.exitCode = 2;
+  throw error;
+}
+
+function printJsonOr(value, json, human) {
+  if (json) process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+  else process.stdout.write(`${human}\n`);
+}
+
+async function run(argv) {
+  const { command, options } = parseArguments(argv);
+  if (options.version || command === 'version') return process.stdout.write(`${VERSION}\n`);
+  if (options.help || command === 'help') return process.stdout.write(helpText());
+  const credentials = resolveCredentials(options);
+
+  if (command === 'login') {
+    if (options.token && options.token !== true) {
+      const me = await request(credentials.apiBase, '/me', { token: options.token });
+      saveSession({ token: options.token, apiBase: credentials.apiBase });
+      return printJsonOr(me, options.json, `Вход выполнен: ${me.user.email}`);
+    }
+    const user = await loginWithBrowser(credentials.apiBase, { noBrowser: Boolean(options.noBrowser), output: options.json ? process.stderr : process.stdout });
+    return printJsonOr({ user }, options.json, `Готово. CLI подключён к ${user.email}`);
+  }
+
+  if (command === 'logout') {
+    clearSession();
+    return process.stdout.write('Локальная сессия Deploya удалена.\n');
+  }
+
+  const token = requireToken(credentials);
+
+  if (command === 'whoami') {
+    const result = await request(credentials.apiBase, '/me', { token });
+    return printJsonOr(result, options.json, `${result.user.email} · тариф ${result.user.plan}`);
+  }
+
+  if (command === 'projects') {
+    const result = await request(credentials.apiBase, '/projects', { token });
+    if (options.json) return printJsonOr(result, true, '');
+    if (!result.projects.length) return process.stdout.write('Проектов пока нет. Первый создаст deploya deploy --prod.\n');
+    process.stdout.write(`${'ID'.padEnd(8)} ${'Название'.padEnd(28)} Адрес\n`);
+    for (const project of result.projects) process.stdout.write(`${String(project.id).padEnd(8)} ${String(project.name).slice(0, 27).padEnd(28)} ${project.url}\n`);
+    return;
+  }
+
+  if (command === 'link') {
+    const projectId = Number(options.project || 0);
+    if (!projectId) throw new Error('Укажите проект: deploya link --project ID');
+    const result = await request(credentials.apiBase, `/projects/${projectId}`, { token });
+    saveProject(process.cwd(), { projectId: result.project.id, teamId: result.project.teamId, name: result.project.name, url: result.project.url });
+    return printJsonOr(result, options.json, `Папка связана с «${result.project.name}» (${result.project.url}).`);
+  }
+
+  if (command === 'deploy') {
+    const projectRoot = process.cwd();
+    const linked = loadProject(projectRoot);
+    const projectId = Number(options.project || linked.projectId || 0) || null;
+    const target = options.prod ? 'production' : 'preview';
+    if (!projectId && target === 'preview') {
+      const error = new Error('Это первый деплой проекта. Добавьте --prod, чтобы создать его и получить постоянный адрес.');
+      error.hint = 'Пример: npx @deploya-app/cli deploy --dir dist --prod';
+      throw error;
+    }
+    const directory = path.resolve(projectRoot, options.dir && options.dir !== true ? options.dir : '.');
+    const name = options.name && options.name !== true ? options.name : path.basename(projectRoot);
+    const result = await deployDirectory({
+      apiBase: credentials.apiBase,
+      token,
+      directory,
+      projectId,
+      name,
+      subdomain: options.subdomain === true ? '' : options.subdomain,
+      teamId: options.team === true ? '' : options.team,
+      entrypoint: options.entrypoint === true ? '' : options.entrypoint,
+      target,
+      onProgress: options.json ? (message) => process.stderr.write(`${message}\n`) : (message) => process.stdout.write(`${message}\n`),
+    });
+    saveProject(projectRoot, {
+      projectId: result.project.id,
+      teamId: result.project.teamId,
+      name: result.project.name,
+      url: result.project.url,
+    });
+    if (options.json) return printJsonOr(result, true, '');
+    process.stdout.write(`Готово: ${result.deployment.url}\n`);
+    if (result.deployment.url !== result.deployment.productionUrl) process.stdout.write(`Production: ${result.deployment.productionUrl}\n`);
+    return;
+  }
+
+  const error = new Error(`Неизвестная команда: ${command}`);
+  error.hint = 'Выполните deploya --help, чтобы увидеть список команд.';
+  throw error;
+}
+
+function helpText() {
+  return `Deploya CLI ${VERSION}
+
+Публикация статических сайтов из терминала и AI-агентов.
+
+Быстрый старт:
+  npx @deploya-app/cli login
+  npx @deploya-app/cli deploy --dir dist --prod
+
+Команды:
+  login [--no-browser]        Войти через подтверждение в браузере
+  logout                      Удалить локальную сессию
+  whoami                      Показать текущий аккаунт
+  projects                    Показать проекты
+  link --project ID           Связать текущую папку с проектом
+  deploy [--dir PATH]         Создать preview связанного проекта
+  deploy --dir PATH --prod    Опубликовать production-версию
+
+Параметры deploy:
+  --name TEXT                 Название нового проекта
+  --subdomain NAME            Желаемый поддомен
+  --entrypoint FILE           Главный HTML-файл
+  --project ID                Проект без локальной привязки
+  --team ID                   Команда для нового проекта
+  --json                      Машиночитаемый JSON-результат
+
+Общие параметры:
+  --api URL                   Другой сервер Deploya
+  --token TOKEN               API-токен (предпочтительно DEPLOYA_TOKEN)
+  --help, --version
+`;
+}
+
+module.exports = { parseArguments, run };

package/src/config.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const DEFAULT_APP_URL = 'https://app.deploya.ru';
+
+function configDirectory() {
+  if (process.env.DEPLOYA_CONFIG_DIR) return path.resolve(process.env.DEPLOYA_CONFIG_DIR);
+  if (process.platform === 'win32' && process.env.APPDATA) return path.join(process.env.APPDATA, 'Deploya');
+  return path.join(os.homedir(), '.config', 'deploya');
+}
+
+function userConfigPath() {
+  return path.join(configDirectory(), 'config.json');
+}
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch { return {}; }
+}
+
+function writeJsonAtomic(file, value, secret = false) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: secret ? 0o600 : 0o644 });
+  fs.renameSync(temporary, file);
+  if (secret && process.platform !== 'win32') fs.chmodSync(file, 0o600);
+}
+
+function normalizeApiBase(value) {
+  const source = String(value || DEFAULT_APP_URL).trim().replace(/\/+$/, '');
+  return source.endsWith('/api/v1') ? source : `${source}/api/v1`;
+}
+
+function loadUserConfig() {
+  return readJson(userConfigPath());
+}
+
+function saveSession({ token, apiBase }) {
+  const current = loadUserConfig();
+  writeJsonAtomic(userConfigPath(), { ...current, token, apiBase: normalizeApiBase(apiBase), updatedAt: new Date().toISOString() }, true);
+}
+
+function clearSession() {
+  const current = loadUserConfig();
+  delete current.token;
+  writeJsonAtomic(userConfigPath(), current, true);
+}
+
+function resolveCredentials(options = {}) {
+  const stored = loadUserConfig();
+  const token = options.token || process.env.DEPLOYA_TOKEN || stored.token || '';
+  const apiBase = normalizeApiBase(options.api || process.env.DEPLOYA_API_URL || stored.apiBase || DEFAULT_APP_URL);
+  return { token, apiBase };
+}
+
+function projectConfigPath(root = process.cwd()) {
+  return path.join(path.resolve(root), '.deploya', 'project.json');
+}
+
+function loadProject(root = process.cwd()) {
+  return readJson(projectConfigPath(root));
+}
+
+function saveProject(root, project) {
+  writeJsonAtomic(projectConfigPath(root), {
+    projectId: Number(project.projectId),
+    teamId: project.teamId ? Number(project.teamId) : null,
+    name: project.name || '',
+    url: project.url || '',
+  });
+}
+
+module.exports = { clearSession, loadProject, loadUserConfig, normalizeApiBase, resolveCredentials, saveProject, saveSession, userConfigPath };

package/src/deploy.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { createArchive } = require('./archive');
+const { request } = require('./api');
+
+async function archiveBlob(archivePath) {
+  if (typeof fs.openAsBlob === 'function') return fs.openAsBlob(archivePath, { type: 'application/zip' });
+  return new Blob([fs.readFileSync(archivePath)], { type: 'application/zip' });
+}
+
+async function deployDirectory({ apiBase, token, directory, projectId, name, subdomain, teamId, entrypoint, target, onProgress }) {
+  onProgress?.('Собираем безопасный ZIP-архив…');
+  const archive = createArchive(directory);
+  try {
+    onProgress?.(`Загружаем ${archive.fileCount} файлов (${formatBytes(archive.bytes)})…`);
+    const form = new FormData();
+    form.append('archive', await archiveBlob(archive.archivePath), 'site.zip');
+    if (projectId) form.append('projectId', String(projectId));
+    if (name) form.append('name', name);
+    if (subdomain) form.append('subdomain', subdomain);
+    if (teamId) form.append('teamId', String(teamId));
+    if (entrypoint) form.append('entrypoint', entrypoint);
+    form.append('target', target);
+    return await request(apiBase, '/deployments', {
+      method: 'POST',
+      token,
+      body: form,
+      timeout: 10 * 60 * 1000,
+      headers: { 'Idempotency-Key': crypto.randomUUID(), 'User-Agent': 'deploya-cli/0.1.0' },
+    });
+  } finally {
+    archive.cleanup();
+  }
+}
+
+function formatBytes(value) {
+  if (value < 1024) return `${value} Б`;
+  if (value < 1024 ** 2) return `${(value / 1024).toFixed(1)} КБ`;
+  return `${(value / 1024 ** 2).toFixed(1)} МБ`;
+}
+
+module.exports = { deployDirectory, formatBytes };