project-devkit 2.0.0

package/plugins/backups/backups.mjs

@@ -0,0 +1,342 @@
+import { resolve, basename } from 'path';
+import { existsSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+const LOCAL_DUMP_PATTERN = /^dump-(test|stage|local)-(inner|outer)-(\d{4}-\d{2}-\d{2})_(\d{2}_\d{2}_\d{2})\.sql\.gz$/;
+
+// --- YaDisk helpers (internal module) ---
+
+function makeDumpPattern(env) {
+  return new RegExp(`^dump-${env}-(inner|outer)-(\\d{4}-\\d{2}-\\d{2})_(\\d{2}_\\d{2}_\\d{2})\\.sql\\.gz$`);
+}
+
+function getSSHHost(env, config) {
+  const server = config.servers?.[env];
+  if (!server) throw new Error(`Unknown environment '${env}' (available: ${Object.keys(config.servers || {}).join(', ')})`);
+  return server.ssh;
+}
+
+function hasYaDiskToken(config) {
+  const envVar = config.yadisk?.token_env || 'YADISK_TOKEN';
+  return !!process.env[envVar];
+}
+
+function getYaDiskToken(config) {
+  const envVar = config.yadisk?.token_env || 'YADISK_TOKEN';
+  return process.env[envVar];
+}
+
+function getDumpsViaSSH(mode, env, config, utils) {
+  const host = getSSHHost(env, config);
+  const infoScript = config.dump?.info_script || '/opt/get_dump_info.sh';
+  const output = utils.sshExec(host, `${infoScript} ${mode}`);
+  return JSON.parse(output);
+}
+
+async function getDumpsViaYaDisk(env, config, utils) {
+  const token = getYaDiskToken(config);
+  if (!token) throw new Error('YADISK_TOKEN is not set');
+  const pattern = makeDumpPattern(env);
+  const folder = config.yadisk?.folders?.[env];
+  if (!folder) throw new Error(`YaDisk folder for '${env}' not configured`);
+  const items = await utils.listYaDiskDumps(token, folder);
+  return items
+    .filter(item => item.type === 'file' && pattern.test(item.name))
+    .map(item => {
+      const m = item.name.match(pattern);
+      return {
+        name: item.name, path: item.path,
+        type: m[1], date: m[2], time: m[3],
+        size: item.size || 0, source: 'yadisk',
+      };
+    });
+}
+
+async function getDumps(mode, env, config, utils) {
+  try {
+    return getDumpsViaSSH(mode, env, config, utils);
+  } catch {
+    if (hasYaDiskToken(config) && (mode === 'all' || mode === 'remote')) {
+      console.log(chalk.yellow(`SSH ${env} unavailable, using YaDisk API`));
+      return getDumpsViaYaDisk(env, config, utils);
+    }
+    throw new Error(`SSH ${env} unavailable and YADISK_TOKEN not set`);
+  }
+}
+
+async function getDownloadLink(dump, env, config, utils) {
+  try {
+    const host = getSSHHost(env, config);
+    const infoScript = config.dump?.info_script || '/opt/get_dump_info.sh';
+    const url = utils.sshExec(host, `${infoScript} download-link '${dump.path}'`);
+    if (url.startsWith('http')) return url;
+  } catch {}
+  if (hasYaDiskToken(config)) {
+    return utils.getYaDiskDownloadUrl(getYaDiskToken(config), dump.path);
+  }
+  return null;
+}
+
+function getLocalDumps() {
+  const dir = resolve('backups');
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter(f => LOCAL_DUMP_PATTERN.test(f))
+    .map(f => {
+      const m = f.match(LOCAL_DUMP_PATTERN);
+      const fullPath = resolve(dir, f);
+      let size = 0;
+      try { size = statSync(fullPath).size; } catch {}
+      return {
+        name: f, path: fullPath,
+        origin: m[1], type: m[2], date: m[3], time: m[4],
+        size, source: 'local',
+      };
+    });
+}
+
+function groupDumps(dumps) {
+  const groups = {};
+  for (const d of dumps) {
+    const key = `${d.date}_${d.time}`;
+    (groups[key] ||= []).push(d);
+  }
+  return groups;
+}
+
+function findDumpFile(options) {
+  if (options.src) {
+    const src = resolve(options.src);
+    if (!existsSync(src)) throw new Error(`File not found: ${src}`);
+    const name = basename(src);
+    const m = name.match(LOCAL_DUMP_PATTERN);
+    const type = options.type || (m ? m[2] : null);
+    if (!type) throw new Error(`Cannot determine type (inner/outer) from filename. Use --type`);
+    return [{ path: src, name, type }];
+  }
+
+  const dir = resolve('backups');
+  if (!existsSync(dir)) throw new Error('backups/ folder not found');
+
+  let files = readdirSync(dir)
+    .filter(f => LOCAL_DUMP_PATTERN.test(f))
+    .map(f => {
+      const m = f.match(LOCAL_DUMP_PATTERN);
+      return { name: f, path: resolve(dir, f), type: m[2], date: m[3], time: m[4] };
+    });
+
+  if (options.type) files = files.filter(f => f.type === options.type);
+  if (options.date) files = files.filter(f => f.date === options.date);
+  if (files.length === 0) throw new Error('No matching dumps found');
+
+  files.sort((a, b) => `${b.date}_${b.time}`.localeCompare(`${a.date}_${a.time}`));
+
+  const latestKey = `${files[0].date}_${files[0].time}`;
+  return files.filter(f => `${f.date}_${f.time}` === latestKey);
+}
+
+// --- Commands ---
+
+const ORIGIN_COLORS = { test: chalk.blue, stage: chalk.magenta, local: chalk.green };
+
+export function ls({ utils }) {
+  const dumps = getLocalDumps();
+  if (dumps.length === 0) { console.log('No local dumps found (backups/ folder).'); return; }
+
+  const byOrigin = {};
+  for (const d of dumps) {
+    (byOrigin[d.origin] ||= []).push(d);
+  }
+
+  const origins = Object.keys(byOrigin).sort();
+  let totalFiles = 0;
+
+  for (const origin of origins) {
+    const colorFn = ORIGIN_COLORS[origin] || chalk.white;
+    const items = byOrigin[origin];
+    const groups = groupDumps(items);
+    const sortedKeys = Object.keys(groups).sort().reverse();
+    totalFiles += items.length;
+
+    console.log(colorFn(`\n  ${origin} (${items.length} files):`));
+
+    for (const key of sortedKeys) {
+      const group = groups[key];
+      const date = group[0].date;
+      const time = group[0].time.replace(/_/g, ':');
+      const types = group.map(d => chalk.cyan(d.type)).join(', ');
+      const sizes = group.map(d => utils.formatSize(d.size)).join(' + ');
+      const total = utils.formatSize(group.reduce((s, d) => s + d.size, 0));
+
+      console.log(`    ${chalk.green(date)} ${time}  [${types}]  ${sizes} (${total})`);
+    }
+  }
+
+  console.log(`\nTotal: ${totalFiles} files in backups/`);
+}
+
+export async function list({ config, utils, env = 'test', source = 'all' }) {
+  let dumps;
+
+  console.log(chalk.bold(`Environment: ${env}\n`));
+
+  if (source === 'yadisk') {
+    dumps = await getDumpsViaYaDisk(env, config, utils);
+  } else if (source === 'server') {
+    dumps = getDumpsViaSSH('local', env, config, utils);
+  } else {
+    const mode = { all: 'all', server: 'local', yadisk: 'remote' }[source];
+    dumps = await getDumps(mode, env, config, utils);
+  }
+
+  if (dumps.length === 0) { console.log('No dumps found.'); return; }
+
+  const groups = groupDumps(dumps);
+  const sortedKeys = Object.keys(groups).sort().reverse();
+
+  console.log(`Found ${dumps.length} files (${sortedKeys.length} backups):\n`);
+
+  for (const key of sortedKeys) {
+    const items = groups[key];
+    const date = items[0].date;
+    const time = items[0].time.replace(/_/g, ':');
+    const types = items.map(d => chalk.cyan(d.type)).join(', ');
+    const sizes = items.map(d => utils.formatSize(d.size)).join(' + ');
+    const total = utils.formatSize(items.reduce((s, d) => s + d.size, 0));
+    const sources = [...new Set(items.map(d => d.source))].map(s =>
+      s === 'yadisk' ? chalk.yellow(s) : chalk.green(s)
+    ).join('/');
+
+    console.log(`  ${chalk.green(date)} ${time}  [${types}]  ${sizes} (total ${total})  \u2190 ${sources}`);
+  }
+}
+
+export async function pull({ config, utils, env = 'test', type, date, source = 'auto', dest = 'backups' }) {
+  let dumps = await getDumps('all', env, config, utils);
+  if (dumps.length === 0) throw new Error('No dumps found');
+
+  console.log(chalk.bold(`Environment: ${env}\n`));
+
+  if (date) {
+    dumps = dumps.filter(d => d.date === date);
+    if (dumps.length === 0) throw new Error(`No dumps found for ${date}`);
+  }
+
+  if (type) {
+    dumps = dumps.filter(d => d.type === type);
+    if (dumps.length === 0) throw new Error(`No dumps found for type '${type}'`);
+  }
+
+  if (source === 'server') {
+    dumps = dumps.filter(d => d.source === 'server');
+    if (dumps.length === 0) throw new Error('None on server. Try --source yadisk');
+  } else if (source === 'yadisk') {
+    dumps = dumps.filter(d => d.source === 'yadisk');
+    if (dumps.length === 0) throw new Error('None on YaDisk');
+  }
+
+  const groups = groupDumps(dumps);
+  const latestKey = Object.keys(groups).sort().reverse()[0];
+  let toDownload = groups[latestKey];
+
+  if (source === 'auto') {
+    const serverDumps = toDownload.filter(d => d.source === 'server');
+    const yadiskDumps = toDownload.filter(d => d.source === 'yadisk');
+    const seenTypes = new Set();
+    const chosen = [];
+    for (const d of serverDumps) { chosen.push(d); seenTypes.add(d.type); }
+    for (const d of yadiskDumps) { if (!seenTypes.has(d.type)) chosen.push(d); }
+    toDownload = chosen;
+  }
+
+  const destDir = resolve(dest);
+  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+
+  const host = getSSHHost(env, config);
+  const dumpDate = toDownload[0].date;
+  const dumpTime = toDownload[0].time.replace(/_/g, ':');
+  console.log(`Downloading dumps for ${dumpDate} ${dumpTime}:\n`);
+
+  for (const dump of toDownload) {
+    const destFile = resolve(destDir, dump.name);
+
+    if (dump.source === 'server') {
+      console.log(`  ${chalk.green('scp')}    ${dump.name} (${utils.formatSize(dump.size)})`);
+      utils.scpDownload(host, dump.path, destFile);
+    } else {
+      console.log(`  ${chalk.yellow('yadisk')} ${dump.name} (${utils.formatSize(dump.size)})`);
+      const url = await getDownloadLink(dump, env, config, utils);
+      if (!url) { console.log(chalk.red('    Failed to get download link')); continue; }
+      await utils.downloadFromUrl(url, destFile, dump.size);
+    }
+  }
+
+  console.log(chalk.green('\nDone!'));
+}
+
+export async function dump({ config, utils, projectRoot, type, dest = 'backups' }) {
+  const composeFile = config.compose_file || 'docker-compose.dev.yml';
+  const containers = utils.getComposeContainers(projectRoot, composeFile);
+  const types = type ? [type] : Object.keys(containers);
+  const destDir = resolve(dest);
+  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10);
+  const time = now.toTimeString().slice(0, 8).replace(/:/g, '_');
+
+  for (const t of types) {
+    const cfg = containers[t];
+    if (!cfg) throw new Error(`No configuration for type '${t}'`);
+
+    const fileName = `dump-local-${t}-${date}_${time}.sql.gz`;
+    const destFile = resolve(destDir, fileName);
+
+    console.log(`${chalk.cyan(t)}: dumping ${cfg.dbName} from ${cfg.pgContainer}...`);
+
+    execSync(
+      `docker exec ${cfg.pgContainer} pg_dump -U ${cfg.dbUser} ${cfg.dbName} | gzip > "${destFile}"`,
+      { stdio: ['pipe', 'pipe', 'inherit'], timeout: 300000 },
+    );
+
+    console.log(chalk.green(`  \u2192 ${fileName}`));
+  }
+
+  console.log(chalk.green('\nDone!'));
+}
+
+export async function load({ config, utils, projectRoot, type, date, src }) {
+  const dumps = findDumpFile({ type, date, src });
+  const composeFile = config.compose_file || 'docker-compose.dev.yml';
+  const containers = utils.getComposeContainers(projectRoot, composeFile);
+
+  for (const dump of dumps) {
+    const cfg = containers[dump.type];
+    if (!cfg) throw new Error(`No configuration for type '${dump.type}'`);
+
+    console.log(`\n${chalk.cyan(dump.type)}: loading ${dump.name} \u2192 ${cfg.pgContainer}`);
+
+    console.log('  Stopping Directus...');
+    execSync(`docker stop ${cfg.appContainer}`, { stdio: 'pipe', timeout: 30000 });
+
+    try {
+      console.log('  Recreating DB...');
+      utils.dockerExec(cfg.pgContainer, `dropdb -U ${cfg.dbUser} --force --if-exists ${cfg.dbName}`);
+      utils.dockerExec(cfg.pgContainer, `createdb -U ${cfg.dbUser} ${cfg.dbName}`);
+
+      console.log('  Restoring dump...');
+      execSync(
+        `gunzip -c "${dump.path}" | docker exec -i ${cfg.pgContainer} psql -U ${cfg.dbUser} -d ${cfg.dbName}`,
+        { stdio: ['pipe', 'pipe', 'inherit'], timeout: 600000 },
+      );
+
+      console.log(chalk.green(`  ${dump.type}: loaded!`));
+    } finally {
+      console.log('  Starting Directus...');
+      execSync(`docker start ${cfg.appContainer}`, { stdio: 'pipe', timeout: 30000 });
+    }
+  }
+
+  console.log(chalk.green('\nDone!'));
+}

package/plugins/backups/config.yml

@@ -0,0 +1,31 @@
+name: backups
+description: Database backup management — list, download, dump, restore
+
+# YaDisk configuration — override in .devkit.d/backups.yml
+yadisk:
+  token_env: YADISK_TOKEN
+  # folders:
+  #   test: /path/to/backups/test
+  #   stage: /path/to/backups/stage
+
+# Dump file naming
+dump:
+  pattern: "dump-{env}-{type}-{date}_{time}.sql.gz"
+  local_pattern: "dump-{origin}-{type}-{date}_{time}.sql.gz"
+  info_script: /opt/get_dump_info.sh
+
+# Docker compose file for local operations
+compose_file: docker-compose.dev.yml
+
+# Server definitions — override in .devkit.d/backups.yml
+# Example:
+#   servers:
+#     test:
+#       ssh: user@host
+#       projects_path: /opt/projects
+#       confirm: false
+#     stage:
+#       ssh: user@host
+#       projects_path: /opt/projects
+#       confirm: true
+servers: {}

package/plugins/backups/index.mjs

@@ -0,0 +1,53 @@
+import * as backups from './backups.mjs';
+
+function handleError(e) {
+  console.error(`Error: ${e.message}`);
+  process.exit(1);
+}
+
+/**
+ * Register backups plugin commands.
+ * @param {import('commander').Command} program
+ * @param {object} context
+ */
+export function register(program, { config, utils, projectRoot, devkitRoot }) {
+  const ctx = { config, utils, projectRoot };
+  const backupsCmd = program.command('backups').description(config.description || 'Database backups');
+
+  backupsCmd
+    .command('ls')
+    .description('Show local dumps (downloaded and created)')
+    .action(() => { try { backups.ls(ctx); } catch (e) { handleError(e); } });
+
+  backupsCmd
+    .command('list')
+    .description('Show available dumps on server')
+    .option('--env <env>', 'Environment: test or stage', 'test')
+    .option('--source <source>', 'Source: all, server, yadisk', 'all')
+    .action(opts => backups.list({ ...ctx, ...opts }).catch(handleError));
+
+  backupsCmd
+    .command('pull')
+    .description('Download dumps')
+    .option('--env <env>', 'Environment: test, stage or local', 'test')
+    .option('--type <type>', 'Type: inner or outer')
+    .option('--date <date>', 'Dump date (YYYY-MM-DD)')
+    .option('--source <source>', 'Source: auto, server, yadisk', 'auto')
+    .option('--dest <dest>', 'Destination folder', 'backups')
+    .action(opts => backups.pull({ ...ctx, ...opts }).catch(handleError));
+
+  backupsCmd
+    .command('dump')
+    .description('Create a local DB dump')
+    .option('--type <type>', 'Type: inner or outer (default: both)')
+    .option('--dest <dest>', 'Destination folder', 'backups')
+    .action(opts => backups.dump({ ...ctx, ...opts }).catch(handleError));
+
+  backupsCmd
+    .command('load')
+    .description('Restore a dump into a local container')
+    .option('--type <type>', 'Type: inner or outer')
+    .option('--date <date>', 'Dump date (YYYY-MM-DD)')
+    .option('--src <path>', 'Path to .sql.gz file')
+    .action(opts => backups.load({ ...ctx, ...opts }).catch(handleError));
+}

package/plugins/directus/config.yml

@@ -0,0 +1,18 @@
+name: directus
+description: Directus CLI wrapper — run commands inside Directus containers
+
+# Docker compose file to discover containers
+compose_file: docker-compose.dev.yml
+
+# Container aliases — override in .devkit.d/directus.yml
+# Maps short alias to docker-compose service name
+# Example:
+#   aliases:
+#     inner: directus-inner
+#     outer: directus-outer
+aliases: {}
+
+# Snapshot settings
+snapshot:
+  dir: snapshots
+  pattern: "snapshot-{origin}-{type}-{date}.json"

package/plugins/directus/directus.mjs

@@ -0,0 +1,179 @@
+import { resolve, basename } from 'path';
+import { existsSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+const SNAPSHOT_PATTERN = /^snapshot-(local|test|stage)-(inner|outer)-(\d{8})\.json$/;
+
+/**
+ * Resolve a container alias (e.g. "inner" → "directus-inner") or return as-is.
+ */
+function resolveAlias(alias, config) {
+  const aliases = config.aliases || {};
+  return aliases[alias] || alias;
+}
+
+/**
+ * Get all defined aliases as list of { alias, container } pairs.
+ */
+function getAliases(config) {
+  const aliases = config.aliases || {};
+  return Object.entries(aliases).map(([alias, container]) => ({ alias, container }));
+}
+
+/**
+ * Run a Directus CLI command inside a container.
+ */
+export function exec({ config, utils, projectRoot, alias, args = [] }) {
+  const container = resolveAlias(alias, config);
+  const cmd = ['node', 'directus/cli.js', ...args].join(' ');
+
+  console.log(chalk.cyan(`${alias} (${container}): ${cmd}`));
+  try {
+    execSync(`docker exec ${container} ${cmd}`, { stdio: 'inherit', timeout: 120000 });
+  } catch (e) {
+    throw new Error(`Command failed in ${container}: ${e.message}`);
+  }
+}
+
+// --- Snapshot subcommand ---
+
+function formatDate() {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, '0');
+  const d = String(now.getDate()).padStart(2, '0');
+  return `${y}${m}${d}`;
+}
+
+function getLocalSnapshots(snapshotDir) {
+  const dir = resolve(snapshotDir);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter(f => SNAPSHOT_PATTERN.test(f))
+    .map(f => {
+      const m = f.match(SNAPSHOT_PATTERN);
+      const fullPath = resolve(dir, f);
+      let size = 0;
+      try { size = statSync(fullPath).size; } catch {}
+      return { name: f, path: fullPath, origin: m[1], type: m[2], date: m[3], size };
+    });
+}
+
+function findSnapshotFile(options, snapshotDir) {
+  if (options.src) {
+    const src = resolve(options.src);
+    if (!existsSync(src)) throw new Error(`File not found: ${src}`);
+    const name = basename(src);
+    const m = name.match(SNAPSHOT_PATTERN);
+    const type = options.type || (m ? m[2] : null);
+    if (!type) throw new Error(`Cannot determine type (inner/outer) from filename. Use --type`);
+    return [{ path: src, name, type }];
+  }
+
+  const dir = resolve(snapshotDir);
+  if (!existsSync(dir)) throw new Error(`${snapshotDir}/ folder not found`);
+
+  let files = getLocalSnapshots(snapshotDir);
+  if (options.type) files = files.filter(f => f.type === options.type);
+  if (options.date) files = files.filter(f => f.date === options.date.replace(/-/g, ''));
+  if (files.length === 0) throw new Error('No matching snapshots found');
+
+  files.sort((a, b) => b.date.localeCompare(a.date));
+
+  const latestDate = files[0].date;
+  return files.filter(f => f.date === latestDate);
+}
+
+export async function snapshotDump({ config, utils, projectRoot, type, dest }) {
+  const snapshotDir = dest || config.snapshot?.dir || 'snapshots';
+  const aliases = getAliases(config);
+
+  if (aliases.length === 0) {
+    console.log(chalk.yellow('No container aliases configured. Add them to .devkit.d/directus.yml'));
+    return;
+  }
+
+  const types = type ? [type] : aliases.map(a => a.alias);
+  const destDir = resolve(snapshotDir);
+  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+
+  const date = formatDate();
+
+  for (const t of types) {
+    const container = resolveAlias(t, config);
+    const fileName = `snapshot-local-${t}-${date}.json`;
+    const destFile = resolve(destDir, fileName);
+    const tmpFile = `/tmp/snapshot-${t}.json`;
+
+    console.log(`${chalk.cyan(t)} (${container}): schema snapshot...`);
+
+    execSync(
+      `docker exec ${container} sh -c 'node directus/cli.js schema snapshot --format json > ${tmpFile}'`,
+      { stdio: 'inherit', timeout: 60000 },
+    );
+
+    execSync(`docker cp ${container}:${tmpFile} "${destFile}"`, { timeout: 30000 });
+
+    try { execSync(`docker exec ${container} rm ${tmpFile}`, { stdio: 'pipe', timeout: 10000 }); } catch {}
+
+    console.log(chalk.green(`  \u2192 ${fileName}`));
+  }
+
+  console.log(chalk.green('\nDone!'));
+}
+
+export async function snapshotLoad({ config, utils, projectRoot, type, date, src }) {
+  const snapshotDir = config.snapshot?.dir || 'snapshots';
+  const snapshots = findSnapshotFile({ type, date, src }, snapshotDir);
+
+  for (const snap of snapshots) {
+    const container = resolveAlias(snap.type, config);
+    const tmpPath = `/tmp/${snap.name}`;
+
+    console.log(`\n${chalk.cyan(snap.type)} (${container}): applying ${snap.name}`);
+
+    execSync(`docker cp "${snap.path}" ${container}:${tmpPath}`, { timeout: 30000 });
+
+    try {
+      execSync(
+        `docker exec ${container} node directus/cli.js schema apply --yes ${tmpPath}`,
+        { stdio: 'inherit', timeout: 120000 },
+      );
+      console.log(chalk.green(`  ${snap.type}: applied!`));
+    } finally {
+      try { execSync(`docker exec ${container} rm ${tmpPath}`, { stdio: 'pipe', timeout: 10000 }); } catch {}
+    }
+  }
+
+  console.log(chalk.green('\nDone!'));
+}
+
+const ORIGIN_COLORS = { local: chalk.green, test: chalk.blue, stage: chalk.magenta };
+
+export function snapshotLs({ config, utils }) {
+  const snapshotDir = config.snapshot?.dir || 'snapshots';
+  const files = getLocalSnapshots(snapshotDir);
+
+  if (files.length === 0) {
+    console.log(`No snapshots found (${snapshotDir}/ folder).`);
+    return;
+  }
+
+  const byOrigin = {};
+  for (const f of files) {
+    (byOrigin[f.origin] ||= []).push(f);
+  }
+
+  for (const origin of Object.keys(byOrigin).sort()) {
+    const colorFn = ORIGIN_COLORS[origin] || chalk.white;
+    const items = byOrigin[origin].sort((a, b) => b.date.localeCompare(a.date));
+    console.log(colorFn(`\n  ${origin} (${items.length} files):`));
+    for (const item of items) {
+      const dateStr = `${item.date.slice(0, 4)}-${item.date.slice(4, 6)}-${item.date.slice(6, 8)}`;
+      console.log(`    ${chalk.green(dateStr)}  ${chalk.cyan(item.type)}  ${utils.formatSize(item.size)}`);
+    }
+  }
+
+  console.log(`\nTotal: ${files.length} files in ${snapshotDir}/`);
+}

package/plugins/directus/index.mjs

@@ -0,0 +1,54 @@
+import * as directus from './directus.mjs';
+
+function handleError(e) {
+  console.error(`Error: ${e.message}`);
+  process.exit(1);
+}
+
+/**
+ * Register directus plugin commands.
+ * @param {import('commander').Command} program
+ * @param {object} context
+ */
+export function register(program, { config, utils, projectRoot, devkitRoot }) {
+  const ctx = { config, utils, projectRoot };
+
+  const directusCmd = program
+    .command('directus')
+    .description(config.description || 'Directus CLI wrapper');
+
+  // --- exec: run arbitrary directus CLI command ---
+
+  directusCmd
+    .command('exec <alias> [args...]')
+    .description('Run a Directus CLI command inside a container (e.g. devkit directus exec inner schema snapshot)')
+    .action((alias, args) => {
+      try { directus.exec({ ...ctx, alias, args }); } catch (e) { handleError(e); }
+    });
+
+  // --- snapshot subcommand ---
+
+  const snapshotCmd = directusCmd
+    .command('snapshot')
+    .description('Directus schema snapshots');
+
+  snapshotCmd
+    .command('ls')
+    .description('Show local schema snapshots')
+    .action(() => { try { directus.snapshotLs(ctx); } catch (e) { handleError(e); } });
+
+  snapshotCmd
+    .command('dump')
+    .description('Export schema snapshot from Directus containers')
+    .option('--type <type>', 'Type alias: inner or outer (default: all)')
+    .option('--dest <dest>', 'Destination folder')
+    .action(opts => directus.snapshotDump({ ...ctx, ...opts }).catch(handleError));
+
+  snapshotCmd
+    .command('load')
+    .description('Apply schema snapshot to Directus container')
+    .option('--type <type>', 'Type alias: inner or outer')
+    .option('--date <date>', 'Snapshot date (YYYYMMDD or YYYY-MM-DD)')
+    .option('--src <path>', 'Path to .json file')
+    .action(opts => directus.snapshotLoad({ ...ctx, ...opts }).catch(handleError));
+}

package/plugins/docker/config.yml

@@ -0,0 +1,5 @@
+name: docker
+description: Docker environment management — networks, compose helpers
+
+# Docker compose file — override in .devkit.d/docker.yml
+compose_file: docker-compose.dev.yml