project-devkit 2.0.0

package/cli.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import { existsSync, readdirSync, readFileSync, mkdirSync } from 'fs';
+import chalk from 'chalk';
+import { parse as parseYaml } from 'yaml';
+import { loadPlugins, findProject, listAvailablePlugins } from './core/loader.mjs';
+import * as utils from './core/utils.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const devkitRoot = __dirname;
+
+const program = new Command();
+
+program
+  .name('devkit')
+  .description('Plugin-based CLI toolkit for project infrastructure management')
+  .version('2.0.0');
+
+// --- Core commands (always available) ---
+
+program
+  .command('plugins')
+  .description('List available plugins')
+  .action(() => {
+    const available = listAvailablePlugins(devkitRoot);
+
+    console.log(chalk.bold('\nAvailable plugins:\n'));
+    for (const p of available) {
+      console.log(`  ${chalk.cyan(p.name)}  ${chalk.dim(p.description)}`);
+    }
+
+    try {
+      const { plugins } = findProject();
+      console.log(chalk.bold('\nEnabled in this project:\n'));
+      for (const name of plugins) {
+        const isAvailable = available.some(a => a.name === name);
+        const status = isAvailable ? chalk.green('\u2713') : chalk.red('\u2717 not found');
+        console.log(`  ${status} ${name}`);
+      }
+    } catch {
+      console.log(chalk.dim('\n  No .devkit manifest found in current directory tree.'));
+    }
+    console.log();
+  });
+
+program
+  .command('init')
+  .description('Create .devkit manifest and .devkit.d/ config directory')
+  .action(async () => {
+    const cwd = process.cwd();
+    const manifestPath = resolve(cwd, '.devkit');
+    const configDir = resolve(cwd, '.devkit.d');
+
+    if (existsSync(manifestPath)) {
+      console.log(chalk.yellow('.devkit already exists.'));
+    } else {
+      const available = listAvailablePlugins(devkitRoot);
+      const pluginList = available.map(p => `# ${p.name}`).join('\n');
+      const { writeFileSync } = await import('fs');
+      writeFileSync(manifestPath, `# Enabled devkit plugins (one per line)\n${pluginList}\n`);
+      console.log(chalk.green('Created .devkit'));
+    }
+
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir);
+      console.log(chalk.green('Created .devkit.d/'));
+    }
+
+    console.log(chalk.dim('\nEdit .devkit to uncomment the plugins you need.'));
+    console.log(chalk.dim('Add plugin overrides in .devkit.d/{plugin}.yml'));
+  });
+
+program
+  .command('setup')
+  .description('Full project setup: env files, Docker networks, required directories')
+  .option('--env-name <env>', 'Infisical environment', 'dev')
+  .option('--force', 'Overwrite existing .env files')
+  .action(async (opts) => {
+    try {
+      const { projectRoot, plugins } = findProject();
+
+      // 1. env init (if env plugin is enabled)
+      if (plugins.includes('env')) {
+        console.log(chalk.bold('\n=== Initializing .env files ==='));
+        const pluginDir = resolve(devkitRoot, 'plugins', 'env');
+        const configPath = resolve(pluginDir, 'config.yml');
+        let config = {};
+        if (existsSync(configPath)) {
+          config = parseYaml(readFileSync(configPath, 'utf-8')) || {};
+        }
+        const overridePath = resolve(projectRoot, '.devkit.d', 'env.yml');
+        if (existsSync(overridePath)) {
+          const { deepMerge } = await import('./core/loader.mjs');
+          const overrides = parseYaml(readFileSync(overridePath, 'utf-8')) || {};
+          config = deepMerge(config, overrides);
+        }
+
+        const envModule = await import('./plugins/env/env.mjs');
+        await envModule.init({
+          config, utils, projectRoot,
+          envName: opts.envName, force: opts.force,
+        });
+      }
+
+      // 2. Docker networks (if docker plugin is enabled)
+      if (plugins.includes('docker')) {
+        console.log(chalk.bold('\n=== Docker networks ==='));
+        const pluginDir = resolve(devkitRoot, 'plugins', 'docker');
+        const configPath = resolve(pluginDir, 'config.yml');
+        let config = {};
+        if (existsSync(configPath)) {
+          config = parseYaml(readFileSync(configPath, 'utf-8')) || {};
+        }
+        const overridePath = resolve(projectRoot, '.devkit.d', 'docker.yml');
+        if (existsSync(overridePath)) {
+          const { deepMerge } = await import('./core/loader.mjs');
+          const overrides = parseYaml(readFileSync(overridePath, 'utf-8')) || {};
+          config = deepMerge(config, overrides);
+        }
+
+        const composeFile = config.compose_file || 'docker-compose.dev.yml';
+        const networks = utils.getComposeExternalNetworks(projectRoot, composeFile);
+        if (networks.length === 0) {
+          console.log('  No external networks found.');
+        } else {
+          const created = utils.ensureDockerNetworks(projectRoot, composeFile);
+          for (const net of networks) {
+            if (created.includes(net)) {
+              console.log(chalk.green(`  Created network: ${net}`));
+            } else {
+              console.log(`  Network exists: ${net}`);
+            }
+          }
+        }
+      }
+
+      // 3. Upload directories
+      console.log(chalk.bold('\n=== Directories ==='));
+      const dirs = ['apps/inner/uploads', 'apps/outer/uploads'];
+      for (const dir of dirs) {
+        const fullPath = resolve(projectRoot, dir);
+        if (!existsSync(fullPath)) {
+          mkdirSync(fullPath, { recursive: true });
+          console.log(chalk.green(`  Created: ${dir}`));
+        } else {
+          console.log(`  Exists: ${dir}`);
+        }
+      }
+
+      console.log(chalk.green('\n\u2713 Project ready'));
+    } catch (e) {
+      console.error(`Error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+
+// --- Load plugins dynamically ---
+
+try {
+  await loadPlugins(program, utils, devkitRoot);
+} catch (e) {
+  // If no .devkit found, still allow core commands (plugins, init)
+  if (!process.argv.slice(2).some(a => ['plugins', 'init', '--help', '-h', '--version', '-V'].includes(a))) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+}
+
+program.parse();

package/core/loader.mjs

@@ -0,0 +1,151 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { parse as parseYaml } from 'yaml';
+import chalk from 'chalk';
+
+/**
+ * Find the project root by walking up from cwd looking for a .devkit file.
+ * @returns {{ projectRoot: string, plugins: string[] }} or throws
+ */
+export function findProject(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  const root = resolve('/');
+
+  while (dir !== root) {
+    const manifestPath = resolve(dir, '.devkit');
+    if (existsSync(manifestPath)) {
+      const plugins = parseManifest(manifestPath);
+      return { projectRoot: dir, plugins };
+    }
+    dir = dirname(dir);
+  }
+
+  throw new Error(
+    'No .devkit manifest found.\n' +
+    'Create a .devkit file in your project root listing the plugins you need:\n\n' +
+    '  # .devkit\n' +
+    '  env\n' +
+    '  backups\n' +
+    '  docker\n'
+  );
+}
+
+/**
+ * Parse .devkit manifest — plain text, one plugin per line, # for comments.
+ */
+function parseManifest(filePath) {
+  const content = readFileSync(filePath, 'utf-8');
+  return content
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('#'));
+}
+
+/**
+ * Deep merge two objects. Arrays are replaced, not concatenated.
+ */
+export function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] !== null &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key]) &&
+      typeof result[key] === 'object' &&
+      result[key] !== null &&
+      !Array.isArray(result[key])
+    ) {
+      result[key] = deepMerge(result[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+/**
+ * Load plugin config: merge plugin defaults with project overrides.
+ */
+function loadPluginConfig(pluginDir, projectRoot, pluginName) {
+  // Layer 1: Plugin defaults
+  let config = {};
+  const defaultsPath = resolve(pluginDir, 'config.yml');
+  if (existsSync(defaultsPath)) {
+    config = parseYaml(readFileSync(defaultsPath, 'utf-8')) || {};
+  }
+
+  // Layer 2: Project overrides (.devkit.d/{name}.yml)
+  const overridePath = resolve(projectRoot, '.devkit.d', `${pluginName}.yml`);
+  if (existsSync(overridePath)) {
+    const overrides = parseYaml(readFileSync(overridePath, 'utf-8')) || {};
+    config = deepMerge(config, overrides);
+  }
+
+  return config;
+}
+
+/**
+ * Load and register all plugins from the manifest.
+ *
+ * @param {import('commander').Command} program
+ * @param {object} utils — shared utilities from core/utils.mjs
+ * @param {string} devkitRoot — path to devkit package root
+ */
+export async function loadPlugins(program, utils, devkitRoot) {
+  const { projectRoot, plugins } = findProject();
+
+  const pluginsDir = resolve(devkitRoot, 'plugins');
+
+  for (const pluginName of plugins) {
+    const pluginDir = resolve(pluginsDir, pluginName);
+    const entryPoint = resolve(pluginDir, 'index.mjs');
+
+    if (!existsSync(entryPoint)) {
+      console.warn(chalk.yellow(`  Warning: plugin '${pluginName}' not found at ${pluginDir}/`));
+      continue;
+    }
+
+    const config = loadPluginConfig(pluginDir, projectRoot, pluginName);
+
+    try {
+      const plugin = await import(entryPoint);
+      if (typeof plugin.register !== 'function') {
+        console.warn(chalk.yellow(`  Warning: plugin '${pluginName}' has no register() function`));
+        continue;
+      }
+      plugin.register(program, { config, utils, projectRoot, devkitRoot });
+    } catch (e) {
+      console.error(chalk.red(`  Error loading plugin '${pluginName}': ${e.message}`));
+    }
+  }
+
+  return { projectRoot, plugins };
+}
+
+/**
+ * List all available plugins in the plugins directory.
+ */
+export function listAvailablePlugins(devkitRoot) {
+  const pluginsDir = resolve(devkitRoot, 'plugins');
+  if (!existsSync(pluginsDir)) return [];
+
+  const entries = readdirSync(pluginsDir);
+  const plugins = [];
+
+  for (const name of entries) {
+    const dir = resolve(pluginsDir, name);
+    try {
+      if (!statSync(dir).isDirectory()) continue;
+    } catch { continue; }
+
+    const configPath = resolve(dir, 'config.yml');
+    let description = '';
+    if (existsSync(configPath)) {
+      const cfg = parseYaml(readFileSync(configPath, 'utf-8')) || {};
+      description = cfg.description || '';
+    }
+    plugins.push({ name, description });
+  }
+
+  return plugins;
+}

package/core/utils.mjs

@@ -0,0 +1,259 @@
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, basename } from 'path';
+import chalk from 'chalk';
+import { parse as parseYaml } from 'yaml';
+import { InfisicalClient } from '@infisical/sdk';
+
+// --- .env ---
+
+export function loadEnv(filePath) {
+  if (!existsSync(filePath)) return;
+  const content = readFileSync(filePath, 'utf-8');
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key && !(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+
+export function parseEnv(content) {
+  const result = {};
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key) result[key] = value;
+  }
+  return result;
+}
+
+export function mergeSecretsIntoEnv(envContent, secrets) {
+  const existing = parseEnv(envContent);
+  const lines = envContent.split('\n');
+  let updated = 0;
+
+  for (const [key, value] of Object.entries(secrets)) {
+    if (key in existing) {
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith(`${key}=`) || trimmed.startsWith(`${key} =`)) {
+          lines[i] = `${key}=${value}`;
+          updated++;
+          break;
+        }
+      }
+    } else {
+      lines.push(`${key}=${value}`);
+      updated++;
+    }
+  }
+
+  return { content: lines.join('\n'), updated };
+}
+
+// --- Docker / Compose ---
+
+export function parseComposeFile(projectRoot, composeFile = 'docker-compose.dev.yml') {
+  const composePath = resolve(projectRoot, composeFile);
+  if (!existsSync(composePath)) {
+    throw new Error(`Compose file not found: ${composePath}`);
+  }
+  return parseYaml(readFileSync(composePath, 'utf-8'));
+}
+
+export function getComposeExternalNetworks(projectRoot, composeFile) {
+  const doc = parseComposeFile(projectRoot, composeFile);
+  const networks = doc.networks || {};
+  const external = [];
+  for (const [name, cfg] of Object.entries(networks)) {
+    if (cfg && cfg.external) {
+      external.push(name);
+    }
+  }
+  return external;
+}
+
+export function ensureDockerNetworks(projectRoot, composeFile) {
+  const networks = getComposeExternalNetworks(projectRoot, composeFile);
+  if (networks.length === 0) return [];
+
+  const existing = execSync('docker network ls --format "{{.Name}}"', { encoding: 'utf-8' })
+    .trim().split('\n').filter(Boolean);
+
+  const created = [];
+  for (const net of networks) {
+    if (!existing.includes(net)) {
+      execSync(`docker network create ${net}`, { encoding: 'utf-8' });
+      created.push(net);
+    }
+  }
+  return created;
+}
+
+export function getComposeContainers(projectRoot, composeFile) {
+  const doc = parseComposeFile(projectRoot, composeFile);
+  const services = doc.services || {};
+  const result = {};
+
+  for (const [name, svc] of Object.entries(services)) {
+    const match = name.match(/^postgres-(inner|outer)$/);
+    if (!match) continue;
+    const variant = match[1];
+
+    const containerName = svc.container_name || name;
+
+    const envFiles = Array.isArray(svc.env_file) ? svc.env_file : [svc.env_file].filter(Boolean);
+    let dbUser = 'postgres';
+    let dbName = 'crosses';
+
+    for (const ef of envFiles) {
+      const envPath = resolve(projectRoot, ef);
+      if (!existsSync(envPath)) continue;
+      const vars = parseEnv(readFileSync(envPath, 'utf-8'));
+      if (vars.DB_USER) dbUser = vars.DB_USER;
+      if (vars.DB_DATABASE) dbName = vars.DB_DATABASE;
+    }
+
+    const appServiceName = `directus-${variant}`;
+    const appSvc = services[appServiceName];
+    const appContainer = appSvc?.container_name || appServiceName;
+
+    result[variant] = { pgContainer: containerName, appContainer, dbUser, dbName };
+  }
+
+  return result;
+}
+
+export function dockerExec(container, cmd, options = {}) {
+  const flags = options.interactive ? '-i' : '';
+  return execSync(`docker exec ${flags} ${container} ${cmd}`, {
+    encoding: options.encoding || 'utf-8',
+    stdio: options.stdio || 'pipe',
+    timeout: options.timeout || 60000,
+    ...options.execOptions,
+  });
+}
+
+// --- SSH ---
+
+export function sshExec(host, cmd) {
+  return execSync(`ssh ${host} '${cmd}'`, { encoding: 'utf-8', timeout: 30000 }).trim();
+}
+
+export function sshReadFile(host, path) {
+  try { return sshExec(host, `cat ${path}`); } catch { return ''; }
+}
+
+export function sshWriteFile(host, path, content) {
+  execSync(`ssh ${host} 'cat > ${path}'`, { input: content, encoding: 'utf-8', timeout: 10000 });
+}
+
+export function scpDownload(host, remotePath, localPath) {
+  execSync(`scp ${host}:${remotePath} ${localPath}`, { stdio: 'inherit' });
+}
+
+// --- Infisical SDK ---
+
+const infisicalClients = new Map();
+
+export async function getInfisicalClient({ siteUrl, clientId, clientSecret }) {
+  const key = `${siteUrl}:${clientId}`;
+  if (infisicalClients.has(key)) return infisicalClients.get(key);
+
+  const client = new InfisicalClient({
+    siteUrl,
+    auth: {
+      universalAuth: { clientId, clientSecret },
+    },
+  });
+  infisicalClients.set(key, client);
+  return client;
+}
+
+export async function fetchInfisicalSecrets({ siteUrl, clientId, clientSecret, projectId, envSlug, secretPath }) {
+  const client = await getInfisicalClient({ siteUrl, clientId, clientSecret });
+  return client.listSecrets({
+    projectId,
+    environment: envSlug,
+    path: secretPath,
+  });
+}
+
+// --- YaDisk API ---
+
+async function yadiskRequest(path, token, params = {}) {
+  const url = new URL(`https://cloud-api.yandex.net/v1/disk/resources${path}`);
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+  const resp = await fetch(url, { headers: { Authorization: `OAuth ${token}` } });
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`YaDisk API (${resp.status}): ${body}`);
+  }
+  return resp.json();
+}
+
+export async function listYaDiskDumps(token, folder) {
+  const data = await yadiskRequest('', token, { path: folder, limit: '200', sort: '-modified' });
+  return (data._embedded?.items || []);
+}
+
+export async function getYaDiskDownloadUrl(token, filePath) {
+  const data = await yadiskRequest('/download', token, { path: filePath });
+  return data.href;
+}
+
+export async function downloadFromUrl(url, destPath, size = 0) {
+  const resp = await fetch(url);
+  if (!resp.ok) throw new Error(`Download failed: ${resp.status}`);
+
+  const total = size || parseInt(resp.headers.get('content-length') || '0', 10);
+  const reader = resp.body.getReader();
+  const chunks = [];
+  let downloaded = 0;
+
+  const fileName = basename(destPath);
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    downloaded += value.length;
+    if (total) {
+      const pct = Math.round((downloaded / total) * 100);
+      const bar = '\u2588'.repeat(Math.round(pct / 2)) + '\u2591'.repeat(50 - Math.round(pct / 2));
+      process.stdout.write(`\r  ${fileName} ${bar} ${pct}%`);
+    }
+  }
+  if (total) process.stdout.write('\n');
+
+  const buffer = Buffer.concat(chunks);
+  writeFileSync(destPath, buffer);
+}
+
+// --- Formatting ---
+
+export function formatSize(bytes) {
+  for (const unit of ['B', 'KB', 'MB', 'GB']) {
+    if (bytes < 1024) return `${bytes.toFixed(1)} ${unit}`;
+    bytes /= 1024;
+  }
+  return `${bytes.toFixed(1)} TB`;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "project-devkit",
+  "version": "2.0.0",
+  "description": "Plugin-based CLI toolkit for project infrastructure management",
+  "type": "module",
+  "bin": {
+    "devkit": "./cli.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "core/",
+    "plugins/",
+    "README.md"
+  ],
+  "dependencies": {
+    "@infisical/sdk": "^2.0.0",
+    "@inquirer/prompts": "^7.0.0",
+    "chalk": "^5.0.0",
+    "commander": "^13.0.0",
+    "yaml": "^2.8.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nike4192/devkit.git"
+  },
+  "license": "MIT"
+}

package/plugins/backups/README.md

@@ -0,0 +1,88 @@
+# Backups Plugin
+
+Управление бэкапами базы данных — список, скачивание, создание и накатка дампов.
+
+## Команды
+
+| Команда | Описание |
+|---------|----------|
+| `devkit backups ls` | Показать локальные дампы (скачанные и созданные) |
+| `devkit backups list --env test` | Доступные дампы на сервере |
+| `devkit backups pull --env test` | Скачать дамп с сервера |
+| `devkit backups dump` | Создать локальный дамп БД |
+| `devkit backups load` | Накатить дамп в локальный контейнер |
+
+## Конфигурация
+
+Плагин настраивается через `config.yml` внутри плагина и может быть переопределён в `devkit.yml` проекта:
+
+```yaml
+# devkit.yml
+plugins:
+  backups:
+    yadisk:
+      folders:
+        test: /Projects/crosses/backups/test
+        stage: /Projects/crosses/backups/stage
+    
+    servers:
+      test:
+        ssh: root@45.86.182.200
+      stage:
+        ssh: root@185.93.108.63
+```
+
+## Источники дампов
+
+- **server** — скачивание через SCP с удалённого сервера
+- **yadisk** — скачивание через YaDisk API (требуется `YADISK_TOKEN`)
+- **local** — дампы, созданные через `devkit backups dump`
+
+## Формат имён файлов
+
+```
+dump-{env}-{type}-{date}_{time}.sql.gz
+
+Примеры:
+  dump-test-inner-2026-04-03_14_30_00.sql.gz
+  dump-stage-outer-2026-04-02_04_00_00.sql.gz
+  dump-local-inner-2026-04-03_15_00_00.sql.gz
+```
+
+## Примеры использования
+
+```bash
+# Посмотреть локальные дампы
+devkit backups ls
+
+# Список дампов на тестовом сервере
+devkit backups list --env test
+
+# Список на stage, только с YaDisk
+devkit backups list --env stage --source yadisk
+
+# Скачать свежий дамп со stage
+devkit backups pull --env stage
+
+# Создать дамп локальной БД
+devkit backups dump
+
+# Накатить свежий дамп
+devkit backups load
+
+# Накатить конкретный файл
+devkit backups load --src backups/dump-test-inner-2026-04-03_14_30_00.sql.gz
+```
+
+## Переменные окружения
+
+| Переменная | Описание |
+|-----------|----------|
+| `YADISK_TOKEN` | Токен Яндекс.Диска для скачивания бэкапов |
+| `COMPOSE_FILE` | Путь к docker-compose файлу (по умолчанию `docker-compose.dev.yml`) |
+
+## Зависимости
+
+- Docker + docker-compose
+- SSH доступ к серверам (test/stage)
+- YaDisk API (опционально, как fallback)