@mohamed1_1ibrahim/dcli 1.0.0 → 1.1.0

package/README.md

@@ -15,7 +15,7 @@
 ## Installation
 
 ```bash
-npm install -g dcli
+npm install -g @mohamed1_1ibrahim/dcli
 ```
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohamed1_1ibrahim/dcli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Database CLI - MongoDB data management tool (export, import, ping, info)",
   "main": "src/main.js",
   "bin": {

package/src/commands/autoClone.js

@@ -0,0 +1,56 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { connect, exportDatabase, extractDbName } from '../utils/mongodb.js';
+import { readCloneConfig } from '../utils/cloneConfig.js';
+import { success, error, info, highlight } from '../utils/logger.js';
+
+export async function autoCloneCommand(options) {
+  try {
+    const config = await readCloneConfig();
+    const databases = config.databases;
+
+    if (databases.length === 0) {
+      info('No databases in the clone list. Add some with "dcli clone-add <uri>".');
+      process.exit(0);
+    }
+
+    const outputDir = options.output || process.cwd();
+    await mkdir(outputDir, { recursive: true });
+
+    highlight(`── Auto Clone: ${databases.length} database(s) ──`);
+
+    let cloned = 0;
+    let failed = 0;
+
+    for (const entry of databases) {
+      const label = entry.name || entry.uri;
+      try {
+        info(`Cloning: ${label}`);
+        const client = await connect(entry.uri);
+        const dbName = extractDbName(entry.uri);
+        const data = await exportDatabase(client);
+        await client.close();
+
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const fileName = `clone-${timestamp}-${dbName}.json`;
+        const filePath = join(outputDir, fileName);
+        const exportData = {
+          database: dbName,
+          clonedAt: new Date().toISOString(),
+          data,
+        };
+        await writeFile(filePath, JSON.stringify(exportData, null, 2), 'utf-8');
+        success(`Cloned ${label} → ${fileName} (${Object.keys(data).length} collections)`);
+        cloned++;
+      } catch (err) {
+        error(`Failed to clone ${label}: ${err.message}`);
+        failed++;
+      }
+    }
+
+    highlight(`── Done: ${cloned} cloned, ${failed} failed ──`);
+  } catch (err) {
+    error(`Auto-clone failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/autoPing.js

@@ -15,20 +15,52 @@ export async function autoPingCommand(options) {
   }
 
   try {
-    const createCmd = [
-      `schtasks /create`,
-      `/tn "${taskName}"`,
-      `/sc ONLOGON`,
-      `/delay 0000:05`,
-      `/tr "cmd /c dcli ping"`,
-      `/f`,
-    ].join(' ');
+    const schedule = (options.schedule || 'ONLOGON').toUpperCase();
+    const at = options.at;
+    const every = options.every;
+    const delay = options.delay || '5';
+
+    let parts = [`schtasks /create`, `/tn "${taskName}"`, `/f`];
+
+    switch (schedule) {
+      case 'DAILY': {
+        const time = at || '09:00';
+        parts.push(`/sc DAILY`, `/st ${time}`);
+        break;
+      }
+      case 'HOURLY': {
+        const interval = every || '1';
+        parts.push(`/sc HOURLY`, `/mo ${interval}`);
+        break;
+      }
+      case 'ONCE': {
+        const time = at || '09:00';
+        parts.push(`/sc ONCE`, `/st ${time}`);
+        break;
+      }
+      default: {
+        const delayMinutes = Math.max(1, parseInt(delay, 10) || 5);
+        parts.push(`/sc ONLOGON`, `/delay ${String(delayMinutes).padStart(4, '0')}:00`);
+        break;
+      }
+    }
+
+    parts.push(`/tr "cmd /c dcli ping"`);
+    const createCmd = parts.join(' ');
 
     execSync(createCmd, { stdio: 'pipe' });
+
+    const messages = {
+      DAILY: `It will run "dcli ping" daily at ${at || '09:00'}.`,
+      HOURLY: `It will run "dcli ping" every ${every || '1'} hour(s).`,
+      ONCE: `It will run "dcli ping" once at ${at || '09:00'}.`,
+      ONLOGON: `It will run "dcli ping" ${delay ? `${delay} minute(s) after` : ''} you log on.`,
+    };
+
     success(`Task "${taskName}" created successfully.`);
-    info(`It will run "dcli ping" 5 minutes after you log on.`);
+    info(messages[schedule] || messages.ONLOGON);
   } catch (err) {
-    error(`Failed to create task: ${err.message.includes('Access is denied') ? 'Please run as Administrator (right-click terminal → Run as administrator).' : err.message}`);
+    error(`Failed to create task: ${err.message.includes('Access is denied') ? 'Please run as Administrator (right-click terminal \u2192 Run as administrator).' : err.message}`);
     process.exit(1);
   }
 }

package/src/commands/clone.js

@@ -0,0 +1,45 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { connect, exportDatabase, extractDbName } from '../utils/mongodb.js';
+import { readCloneConfig } from '../utils/cloneConfig.js';
+import { readConfig } from '../utils/config.js';
+import { success, error, info, highlight } from '../utils/logger.js';
+
+export async function cloneCommand(name, options) {
+  try {
+    const config = await readCloneConfig();
+    const entry = config.databases.find(e => (e.name && e.name === name) || e.uri === name);
+
+    if (!entry) {
+      error(`Database "${name}" not found in clone list.`);
+      info('Use "dcli clone-add <uri> -n <name>" to add it first.');
+      process.exit(1);
+    }
+
+    const uri = typeof entry === 'string' ? entry : entry.uri;
+    const label = entry.name || uri;
+
+    const outputDir = options.output || process.cwd();
+    await mkdir(outputDir, { recursive: true });
+
+    highlight(`Cloning: ${label}`);
+    const client = await connect(uri);
+    const dbName = extractDbName(uri);
+    const data = await exportDatabase(client);
+    await client.close();
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const fileName = `clone-${timestamp}-${dbName}.json`;
+    const filePath = join(outputDir, fileName);
+    const exportData = {
+      database: dbName,
+      clonedAt: new Date().toISOString(),
+      data,
+    };
+    await writeFile(filePath, JSON.stringify(exportData, null, 2), 'utf-8');
+    success(`Cloned ${label} → ${fileName} (${Object.keys(data).length} collections)`);
+  } catch (err) {
+    error(`Clone failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/cloneAdd.js

@@ -0,0 +1,20 @@
+import { addCloneDatabase } from '../utils/cloneConfig.js';
+import { success, warn, error } from '../utils/logger.js';
+
+export async function cloneAddCommand(uri, options) {
+  try {
+    const name = options.name;
+    const result = await addCloneDatabase(uri, name);
+    const label = name ? `${name} (${uri})` : uri;
+    if (result === 'added') {
+      success(`Database added to clone list: ${label}`);
+    } else if (result === 'updated') {
+      success(`Name updated to "${name}" for ${uri}`);
+    } else {
+      warn(`Database is already in the clone list.`);
+    }
+  } catch (err) {
+    error(`Failed to add database: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/cloneRemove.js

@@ -0,0 +1,16 @@
+import { removeCloneDatabase } from '../utils/cloneConfig.js';
+import { success, warn, error } from '../utils/logger.js';
+
+export async function cloneRemoveCommand(target) {
+  try {
+    const removed = await removeCloneDatabase(target);
+    if (removed) {
+      success(`Database removed from clone list.`);
+    } else {
+      warn(`No database found matching "${target}" in the clone list.`);
+    }
+  } catch (err) {
+    error(`Failed to remove database: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/exportCmd.js

@@ -2,6 +2,7 @@ import { writeFile, mkdir, access } from 'node:fs/promises';
 import { join, extname, dirname, basename } from 'node:path';
 import { constants } from 'node:fs';
 import { connect, exportDatabase, extractDbName } from '../utils/mongodb.js';
+import { resolveName } from '../utils/resolve.js';
 import { success, error, info, highlight } from '../utils/logger.js';
 
 function ensureJsonExt(name) {
@@ -50,6 +51,7 @@ async function getUniquePath(filePath) {
 }
 
 export async function exportCommand(uri, options) {
+  uri = await resolveName(uri);
   const dbName = extractDbName(uri);
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
   const outputName = options.output || `data-${timestamp}-${dbName}`;

package/src/commands/gui.js

@@ -0,0 +1,350 @@
+import { createServer } from 'node:http';
+import { readFileSync, statSync } from 'node:fs';
+import { writeFile, readFile, mkdir, readdir } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, extname, parse } from 'node:path';
+import { execSync } from 'node:child_process';
+import { connect, exportDatabase, importDatabase, dropDatabase, extractDbName, pingDatabase } from '../utils/mongodb.js';
+import { readConfig, addDatabase, removeDatabase } from '../utils/config.js';
+import { readCloneConfig, addCloneDatabase, removeCloneDatabase } from '../utils/cloneConfig.js';
+import { info, success, error } from '../utils/logger.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const GUI_DIR = join(__dirname, '..', 'gui');
+const HTML_PATH = join(GUI_DIR, 'index.html');
+
+function sendJson(res, data, status = 200) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+function parseBody(req) {
+  return new Promise((resolve) => {
+    let body = '';
+    req.on('data', chunk => body += chunk);
+    req.on('end', () => {
+      try { resolve(JSON.parse(body)); }
+      catch { resolve({}); }
+    });
+  });
+}
+
+async function handleApi(req, res) {
+  const method = req.method;
+  const path = req.url.split('?')[0];
+  const body = method === 'POST' || method === 'DELETE' ? await parseBody(req) : {};
+
+  try {
+    // Ping list
+    if (method === 'GET' && path === '/api/ping-list') {
+      const config = await readConfig();
+      return sendJson(res, { databases: config.databases });
+    }
+    if (method === 'POST' && path === '/api/ping-add') {
+      const result = await addDatabase(body.uri, body.name);
+      const msg = result === 'added' ? `Added to ping list: ${body.name || body.uri}` : result === 'updated' ? `Name updated for ${body.uri}` : `Already in ping list`;
+      return sendJson(res, { success: true, message: msg });
+    }
+    if (method === 'POST' && path === '/api/ping-remove') {
+      const removed = await removeDatabase(body.uri);
+      return sendJson(res, { success: removed, message: removed ? 'Removed from ping list' : 'Not found in ping list' });
+    }
+
+    // Clone list
+    if (method === 'GET' && path === '/api/clone-list') {
+      const config = await readCloneConfig();
+      return sendJson(res, { databases: config.databases });
+    }
+    if (method === 'POST' && path === '/api/clone-add') {
+      const result = await addCloneDatabase(body.uri, body.name);
+      const msg = result === 'added' ? `Added to clone list: ${body.name || body.uri}` : result === 'updated' ? `Name updated for ${body.uri}` : `Already in clone list`;
+      return sendJson(res, { success: true, message: msg });
+    }
+    if (method === 'POST' && path === '/api/clone-remove') {
+      const removed = await removeCloneDatabase(body.uri);
+      return sendJson(res, { success: removed, message: removed ? 'Removed from clone list' : 'Not found in clone list' });
+    }
+
+    // Action: Export
+    if (method === 'POST' && path === '/api/action/export') {
+      const { uri, output, format, compact, include, exclude, dryRun } = body;
+      const client = await connect(uri);
+      const dbName = extractDbName(uri);
+      const rawData = await exportDatabase(client);
+      await client.close();
+
+      let data = rawData;
+      if (include && include.length > 0) {
+        const set = new Set(include);
+        data = Object.fromEntries(Object.entries(data).filter(([k]) => set.has(k)));
+      }
+      if (exclude && exclude.length > 0) {
+        const set = new Set(exclude);
+        data = Object.fromEntries(Object.entries(data).filter(([k]) => !set.has(k)));
+      }
+
+      if (Object.keys(data).length === 0) {
+        return sendJson(res, { success: true, message: 'No collections matched the filters' });
+      }
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const outputName = output || `data-${timestamp}-${dbName}`;
+      const fmt = format || 'file';
+      const indent = compact ? 0 : 2;
+      const files = [];
+
+      if (fmt === 'file' || fmt === 'all') {
+        const fileName = `${outputName}.json`;
+        const exportData = { database: dbName, exportedAt: new Date().toISOString(), data };
+        await writeFile(fileName, JSON.stringify(exportData, null, indent), 'utf-8');
+        files.push(fileName);
+      }
+      if (fmt === 'split' || fmt === 'all') {
+        const dirName = extname(outputName) ? outputName.replace(/\.[^.]+$/, '') : outputName;
+        await mkdir(dirName, { recursive: true });
+        for (const [name, docs] of Object.entries(data)) {
+          const fp = join(dirName, `${name}.json`);
+          await writeFile(fp, JSON.stringify(docs, null, indent), 'utf-8');
+          files.push(fp);
+        }
+      }
+
+      return sendJson(res, { success: true, message: `Exported ${Object.keys(data).length} collection(s) to ${files.join(', ')}`, files });
+    }
+
+    // Action: Import
+    if (method === 'POST' && path === '/api/action/import') {
+      const { uri, file, confirm } = body;
+
+      if (!file) return sendJson(res, { success: false, error: 'File path is required' }, 400);
+
+      const isDir = statSync(file).isDirectory();
+
+      if (isDir) {
+        const entries = await readdir(file);
+        const jsonFiles = entries.filter(e => e.endsWith('.json')).sort();
+        const dataToRestore = {};
+        for (const f of jsonFiles) {
+          const content = await readFile(join(file, f), 'utf-8');
+          const parsed = JSON.parse(content);
+          const name = parse(f).name;
+          const docs = Array.isArray(parsed) ? parsed : [];
+          dataToRestore[name] = docs;
+        }
+        const client = await connect(uri);
+        await importDatabase(client, dataToRestore);
+        await client.close();
+        return sendJson(res, { success: true, message: `Restored ${Object.keys(dataToRestore).length} collection(s) from ${file}` });
+      }
+
+      const content = await readFile(file, 'utf-8');
+      const parsed = JSON.parse(content);
+      const isFull = parsed && typeof parsed === 'object' && 'database' in parsed && 'data' in parsed;
+
+      if (isFull) {
+        if (!confirm) return sendJson(res, { success: false, confirm: true, message: 'This will delete current data. Check the confirmation box.' });
+
+        const client = await connect(uri);
+        const currentData = await exportDatabase(client);
+        const backupName = `backup-${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
+        await writeFile(backupName, JSON.stringify({ database: extractDbName(uri), exportedAt: new Date().toISOString(), data: currentData }, null, 2), 'utf-8');
+        await dropDatabase(client);
+        await importDatabase(client, parsed.data);
+        await client.close();
+        return sendJson(res, { success: true, message: `Database restored from ${file}. Backup saved to ${backupName}` });
+      }
+
+      const name = parse(file).name;
+      const docs = Array.isArray(parsed) ? parsed : [];
+      const client = await connect(uri);
+      await importDatabase(client, { [name]: docs });
+      await client.close();
+      return sendJson(res, { success: true, message: `Restored collection "${name}" (${docs.length} documents) from ${file}` });
+    }
+
+    // Action: Ping
+    if (method === 'POST' && path === '/api/action/ping') {
+      const { uri } = body;
+      let entries;
+
+      if (uri) {
+        const config = await readConfig();
+        const named = config.databases.find(e => e.name === uri);
+        entries = named ? [named] : [{ uri }];
+      } else {
+        const config = await readConfig();
+        entries = config.databases;
+      }
+
+      if (entries.length === 0) {
+        return sendJson(res, { success: true, results: [], message: 'No databases to ping' });
+      }
+
+      const results = [];
+      for (const entry of entries) {
+        const label = entry.name || extractDbName(entry.uri) || entry.uri;
+        try {
+          const client = await connect(entry.uri);
+          await pingDatabase(client);
+          await client.close();
+          results.push({ uri: entry.uri, ok: true, message: `Pinged ${label} successfully` });
+        } catch {
+          results.push({ uri: entry.uri, ok: false, message: `Failed to ping ${label}` });
+        }
+      }
+      return sendJson(res, { success: true, results });
+    }
+
+    // Action: Info
+    if (method === 'POST' && path === '/api/action/info') {
+      const { uri } = body;
+      const client = await connect(uri);
+      const db = client.db();
+      const dbName = extractDbName(uri);
+      const collections = await db.listCollections().toArray();
+      const collInfo = [];
+      let totalDocs = 0;
+      for (const coll of collections) {
+        const count = await db.collection(coll.name).countDocuments();
+        totalDocs += count;
+        collInfo.push({ name: coll.name, count });
+      }
+      await client.close();
+      return sendJson(res, { success: true, message: `── ${dbName} ── Collections: ${collections.length}`, dbName, collections: collInfo, totalDocs });
+    }
+
+    // Auto-ping
+    if (method === 'GET' && path === '/api/auto-ping') {
+      try {
+        const out = execSync(`schtasks /query /tn "DCLI-AutoPing" /v /fo csv`, { stdio: 'pipe', encoding: 'utf-8' });
+        const lines = out.split('\n').filter(Boolean);
+        const header = lines[0]?.split(',') || [];
+        const values = lines[1]?.split(',') || [];
+        const idx = (name) => header.findIndex(h => h.replace(/"/g, '').trim() === name);
+        const get = (name) => (values[idx(name)] || '').replace(/"/g, '').trim();
+        return sendJson(res, {
+          scheduled: true,
+          scheduleType: get('Schedule Type') || get('Task To Run'),
+          startTime: get('Start Time'),
+          repeatInterval: get('Repeat: Every'),
+        });
+      } catch {
+        return sendJson(res, { scheduled: false });
+      }
+    }
+    if (method === 'POST' && path === '/api/auto-ping') {
+      const schedule = (body.schedule || 'ONLOGON').toUpperCase();
+      const at = body.at;
+      const every = body.every;
+      const delay = body.delay || '5';
+
+      let parts = ['schtasks /create', '/tn "DCLI-AutoPing"', '/f'];
+
+      switch (schedule) {
+        case 'DAILY': {
+          const time = at || '09:00';
+          parts.push(`/sc DAILY`, `/st ${time}`);
+          break;
+        }
+        case 'HOURLY': {
+          const interval = every || '1';
+          parts.push(`/sc HOURLY`, `/mo ${interval}`);
+          break;
+        }
+        case 'ONCE': {
+          const time = at || '09:00';
+          parts.push(`/sc ONCE`, `/st ${time}`);
+          break;
+        }
+        default: {
+          const delayMinutes = Math.max(1, parseInt(delay, 10) || 5);
+          parts.push(`/sc ONLOGON`, `/delay ${String(delayMinutes).padStart(4, '0')}:00`);
+          break;
+        }
+      }
+
+      parts.push(`/tr "cmd /c dcli ping"`);
+      execSync(parts.join(' '), { stdio: 'pipe' });
+
+      const messages = {
+        DAILY: `Auto-ping task created. It will run "dcli ping" daily at ${at || '09:00'}.`,
+        HOURLY: `Auto-ping task created. It will run "dcli ping" every ${every || '1'} hour(s).`,
+        ONCE: `Auto-ping task created. It will run "dcli ping" once at ${at || '09:00'}.`,
+        ONLOGON: `Auto-ping task created. It will run "dcli ping" ${delay ? `${delay} minute(s) after` : ''} you log on.`,
+      };
+      return sendJson(res, { success: true, message: messages[schedule] || messages.ONLOGON });
+    }
+    if (method === 'DELETE' && path === '/api/auto-ping') {
+      execSync('schtasks /delete /tn "DCLI-AutoPing" /f', { stdio: 'pipe' });
+      return sendJson(res, { success: true, message: 'Auto-ping task removed.' });
+    }
+
+    // Action: Auto-clone
+    if (method === 'POST' && path === '/api/action/auto-clone') {
+      const config = await readCloneConfig();
+      const databases = config.databases;
+      if (databases.length === 0) {
+        return sendJson(res, { success: true, results: [], cloned: 0, failed: 0, message: 'No databases in clone list' });
+      }
+      const outputDir = body.output || process.cwd();
+      await mkdir(outputDir, { recursive: true });
+      const results = [];
+      let cloned = 0;
+      let failed = 0;
+      for (const entry of databases) {
+        const label = entry.name || entry.uri;
+        try {
+          const client = await connect(entry.uri);
+          const dbName = extractDbName(entry.uri);
+          const data = await exportDatabase(client);
+          await client.close();
+          const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+          const fileName = `clone-${timestamp}-${dbName}.json`;
+          const filePath = join(outputDir, fileName);
+          await writeFile(filePath, JSON.stringify({ database: dbName, clonedAt: new Date().toISOString(), data }, null, 2), 'utf-8');
+          results.push({ uri: entry.uri, ok: true, message: `Cloned ${label} -> ${fileName} (${Object.keys(data).length} collections)` });
+          cloned++;
+        } catch (err) {
+          results.push({ uri: entry.uri, ok: false, message: `Failed to clone ${label}: ${err.message}` });
+          failed++;
+        }
+      }
+      return sendJson(res, { success: true, results, cloned, failed });
+    }
+
+    sendJson(res, { error: 'Not found' }, 404);
+  } catch (err) {
+    sendJson(res, { error: err.message }, 500);
+  }
+}
+
+export async function guiCommand(options) {
+  const port = options.port || 3456;
+
+  try {
+    statSync(HTML_PATH);
+  } catch {
+    error(`GUI files not found at ${GUI_DIR}`);
+    process.exit(1);
+  }
+
+  const html = readFileSync(HTML_PATH, 'utf-8');
+
+  const server = createServer((req, res) => {
+    if (req.url.startsWith('/api/')) {
+      return handleApi(req, res);
+    }
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(html);
+  });
+
+  server.listen(port, () => {
+    success(`GUI opened at http://localhost:${port}`);
+    try {
+      execSync(`start http://localhost:${port}`, { stdio: 'ignore' });
+    } catch {
+      info(`Open http://localhost:${port} in your browser`);
+    }
+  });
+}

package/src/commands/importCmd.js

@@ -4,6 +4,7 @@ import { join, parse } from 'node:path';
 import { createInterface } from 'node:readline';
 import { stdin as input, stdout as output } from 'node:process';
 import { connect, exportDatabase, dropDatabase, importDatabase, extractDbName } from '../utils/mongodb.js';
+import { resolveName } from '../utils/resolve.js';
 import { info, warn, success, error } from '../utils/logger.js';
 
 function askQuestion(query) {
@@ -39,6 +40,7 @@ async function loadDirectory(dirPath) {
 }
 
 export async function importCommand(uri, options) {
+  uri = await resolveName(uri);
   const filePath = options.file;
 
   try {

package/src/commands/info.js

@@ -1,7 +1,9 @@
 import { connect, extractDbName } from '../utils/mongodb.js';
+import { resolveName } from '../utils/resolve.js';
 import { info, error, highlight } from '../utils/logger.js';
 
 export async function infoCommand(uri) {
+  uri = await resolveName(uri);
   try {
     const client = await connect(uri);
     const db = client.db();

package/src/commands/pingCmd.js

@@ -8,7 +8,8 @@ async function pingUri(uri) {
     await pingDatabase(client);
     await client.close();
     return true;
-  } catch {
+  } catch (err) {
+    error(`Ping error: ${err.message}`);
     return false;
   }
 }

package/src/commands/show.js

@@ -0,0 +1,30 @@
+import { readConfig } from '../utils/config.js';
+import { readCloneConfig } from '../utils/cloneConfig.js';
+import { info, warn, error, highlight } from '../utils/logger.js';
+
+export async function showCommand(options) {
+  try {
+    const isClone = options.clone;
+    const config = isClone ? await readCloneConfig() : await readConfig();
+    const label = isClone ? 'Clone list' : 'Ping list';
+    const path = isClone ? '~/.dcli/auto-clone.json' : '~/.dcli/refresh.json';
+    const dbs = config.databases || [];
+
+    highlight(`${label} (${path}):`);
+    info(`Database entries: ${dbs.length}`);
+
+    if (dbs.length === 0) {
+      warn(`No databases in the ${label.toLowerCase()}.`);
+      return;
+    }
+
+    for (const [i, entry] of dbs.entries()) {
+      const num = String(i + 1).padStart(2, ' ');
+      const { uri, name } = typeof entry === 'string' ? { uri: entry } : entry;
+      console.log(`  ${num}. ${name ? `${name} ` : ''}${uri}`);
+    }
+  } catch (err) {
+    error(`Failed to show ${label.toLowerCase()}: ${err.message}`);
+    process.exit(1);
+  }
+}