elestio 1.0.0

package/src/commands/services.js

@@ -0,0 +1,294 @@
+import { apiRequest } from '../api.js';
+import { loadConfig } from '../config.js';
+import { findTemplate } from './templates.js';
+import { formatTable, formatService, formatPrice, colors, log, sleep, validateServerName, outputJson } from '../utils.js';
+
+async function listProjectsRaw() {
+  const response = await apiRequest('/api/projects/getList');
+  if (response.status !== 'OK') return [];
+  return response.data?.projects || [];
+}
+
+export async function findServiceAcrossProjects(vmID) {
+  const projects = await listProjectsRaw();
+  for (const project of projects) {
+    const pid = project.projectID;
+    try {
+      const services = await listServicesRaw(pid);
+      const svc = services.find(s => String(s.vmID) === String(vmID));
+      if (svc) return { service: svc, projectId: pid, projectName: project.project_name };
+    } catch { /* skip */ }
+  }
+  return null;
+}
+
+export async function listServicesRaw(projectId = null) {
+  const config = loadConfig();
+  const pid = projectId || config.defaultProject;
+  if (!pid) throw new Error('Project ID required. Use --project or set default with: elestio config --set-default-project <id>');
+
+  const response = await apiRequest('/api/servers/getServices', 'POST', {
+    appid: 'Cloudxx',
+    projectId: String(pid),
+    isActiveService: 'true'
+  });
+
+  return response.servers || response.data?.services || [];
+}
+
+export async function listServices(projectId = null, json = false) {
+  const config = loadConfig();
+  const pid = projectId || config.defaultProject;
+  if (!pid) throw new Error('Project ID required. Use --project or set default with: elestio config --set-default-project <id>');
+
+  const response = await apiRequest('/api/servers/getServices', 'POST', {
+    appid: 'Cloudxx',
+    projectId: String(pid),
+    isActiveService: 'true'
+  });
+
+  if (response.status === 'KO' || response.code === 'AccessDenied') {
+    throw new Error(response.message || 'Access denied.');
+  }
+
+  const services = response.servers || response.data?.services || [];
+
+  if (json) {
+    outputJson(services);
+    return services;
+  }
+
+  if (services.length === 0) {
+    log('info', `No services in project ${pid}`);
+    return [];
+  }
+
+  const columns = [
+    { key: 'displayName', label: 'Name' },
+    { key: 'templateName', label: 'Software' },
+    { key: 'status', label: 'Status' },
+    { key: 'deploymentStatus', label: 'Deploy' },
+    { key: 'vmID', label: 'vmID' },
+    { key: 'ipv4', label: 'IP' }
+  ];
+
+  console.log(`\n${colors.bold}Services in project ${pid} (${services.length})${colors.reset}\n`);
+  console.log(formatTable(services, columns));
+  console.log('');
+  return services;
+}
+
+export async function getServiceDetails(vmID, projectId = null) {
+  const config = loadConfig();
+  const pid = projectId || config.defaultProject;
+  if (!pid) throw new Error('Project ID required');
+
+  const response = await apiRequest('/api/servers/getServerDetails', 'POST', {
+    vmID: String(vmID),
+    projectID: String(pid)
+  });
+
+  if (response.serviceInfos && response.serviceInfos.length > 0) return response.serviceInfos[0];
+  if (response.status === 'OK' && response.data) return response.data;
+  if (response.status === 'KO' || response.message) throw new Error(response.message || 'Failed to get service details');
+  return null;
+}
+
+export async function getServiceByVmId(vmID, projectId = null) {
+  const services = await listServicesRaw(projectId);
+  return services.find(s => String(s.vmID) === String(vmID));
+}
+
+export async function getServerIdFromVmId(vmID, projectId = null) {
+  const service = await getServiceByVmId(vmID, projectId);
+  if (!service) throw new Error(`Service with vmID ${vmID} not found`);
+  return service.id;
+}
+
+export async function deployService(templateNameOrId, options = {}) {
+  const config = loadConfig();
+  const template = await findTemplate(templateNameOrId);
+  if (!template) throw new Error(`Template "${templateNameOrId}" not found. Use: elestio templates search <name>`);
+
+  const projectId = options.project || config.defaultProject;
+  if (!projectId) throw new Error('Project ID required. Use --project or set default');
+
+  const serverName = options.name || `${template.title.toLowerCase().replace(/[^a-z0-9]/g, '-')}-${Date.now().toString(36)}`;
+  const serverType = options.size || config.defaults?.serverType || 'MEDIUM-2C-4G';
+  const datacenter = options.region || config.defaults?.datacenter || 'nbg';
+  const support = options.support || config.defaults?.support || 'level1';
+  const adminEmail = options.email || config.email;
+  const provider = options.provider || config.defaults?.provider || 'netcup';
+  const version = options.version || template.dockerhub_default_tag || 'latest';
+
+  const nameValidation = validateServerName(serverName);
+  if (!nameValidation.valid) throw new Error(nameValidation.error);
+
+  const isCicd = template.title?.toLowerCase().includes('ci-cd') || templateNameOrId?.toLowerCase() === 'cicd';
+  const serviceType = isCicd ? 'CICD' : 'Service';
+
+  if (options.dryRun) {
+    const preview = {
+      template: template.title, templateId: template.id, version,
+      projectId, serverName, provider, datacenter, serverType, support, adminEmail, serviceType
+    };
+
+    if (options.json) {
+      outputJson({ dryRun: true, ...preview });
+      return preview;
+    }
+
+    console.log(`\n${colors.bold}Deployment Preview (--dry-run)${colors.reset}\n`);
+    console.log(`  Software:   ${colors.cyan}${template.title}${colors.reset} (ID: ${template.id})`);
+    console.log(`  Version:    ${version}`);
+    console.log(`  Project:    ${projectId}`);
+    console.log(`  Name:       ${serverName}`);
+    console.log(`  Provider:   ${provider}`);
+    console.log(`  Region:     ${datacenter}`);
+    console.log(`  Size:       ${serverType}`);
+    console.log(`  Support:    ${support}`);
+    console.log(`  Admin:      ${adminEmail}`);
+    console.log('');
+    log('info', 'To deploy, run the same command without --dry-run');
+    return preview;
+  }
+
+  log('info', `Deploying ${template.title} (ID: ${template.id})`);
+  log('info', `  Project: ${projectId} | Name: ${serverName}`);
+  log('info', `  Provider: ${provider} | Size: ${serverType} @ ${datacenter}`);
+
+  const payload = {
+    templateID: String(template.id), serverType, datacenter,
+    providerName: provider, serverName, appid: 'Cloudxx',
+    data: 'data', support, projectId: String(projectId),
+    version, adminEmail, deploymentServiceType: 'normal', serviceType
+  };
+
+  if (isCicd) {
+    payload.cicdPayload = { pipelineName: options.pipelineName || serverName };
+  }
+
+  const response = await apiRequest('/api/servers/createServer', 'POST', payload);
+
+  if (!response.providerServerID && !response.action) {
+    throw new Error(response.message || 'Failed to create service');
+  }
+
+  log('success', `Deployment started! Provider Server ID: ${response.providerServerID}`);
+
+  if (options.wait !== false) {
+    log('info', 'Waiting for deployment to complete...');
+    return await waitForDeployment(response.providerServerID, projectId, options.timeout);
+  }
+
+  return response;
+}
+
+export async function waitForDeployment(vmID, projectId, timeoutMs = 600000) {
+  const start = Date.now();
+  let lastStatus = '';
+
+  while (Date.now() - start < timeoutMs) {
+    const services = await listServicesRaw(projectId);
+    const svc = services.find(s =>
+      String(s.vmID) === String(vmID) || String(s.providerServerID) === String(vmID)
+    );
+
+    if (!svc) { await sleep(10000); continue; }
+
+    if (svc.deploymentStatus !== lastStatus) {
+      lastStatus = svc.deploymentStatus;
+      log('info', `Status: ${svc.deploymentStatus}`);
+    }
+
+    if (svc.deploymentStatus === 'Deployed' && svc.status === 'running') {
+      log('success', 'Deployment complete!');
+      console.log('\n' + formatService(svc) + '\n');
+      return svc;
+    }
+
+    await sleep(15000);
+  }
+
+  throw new Error(`Deployment timed out after ${timeoutMs / 1000}s`);
+}
+
+export async function deleteService(vmID, options = {}) {
+  if (!options.force) throw new Error('Deleting a service requires --force flag');
+
+  const config = loadConfig();
+  const projectId = options.project || config.defaultProject;
+  if (!projectId) throw new Error('Project ID required');
+
+  const response = await apiRequest('/api/servers/deleteServer', 'POST', {
+    vmID: String(vmID),
+    projectID: String(projectId),
+    isDeleteServiceWithBackup: options.withBackups ? 'true' : 'false'
+  });
+
+  if (response.status !== 'OK' && !response.action) {
+    throw new Error(response.message || 'Failed to delete service');
+  }
+
+  log('success', `Service ${vmID} deletion initiated`);
+  return response;
+}
+
+export async function moveService(vmIDOrServerID, targetProjectId, sourceProjectId = null) {
+  const config = loadConfig();
+  const sourcePid = sourceProjectId || config.defaultProject;
+
+  let serverID = vmIDOrServerID;
+  let foundInProject = null;
+
+  try {
+    const service = await getServiceByVmId(vmIDOrServerID, sourcePid);
+    if (service?.id) { serverID = service.id; foundInProject = sourcePid; }
+  } catch { /* not found */ }
+
+  if (!foundInProject) {
+    log('info', `Searching across all projects...`);
+    const found = await findServiceAcrossProjects(vmIDOrServerID);
+    if (found) {
+      serverID = found.service.id;
+      log('info', `Found in project "${found.projectName}" (${found.projectId})`);
+    } else {
+      throw new Error(`Service ${vmIDOrServerID} not found in any project`);
+    }
+  }
+
+  const response = await apiRequest('/api/servers/moveService', 'PUT', {
+    serviceId: String(serverID),
+    projectId: String(targetProjectId)
+  });
+
+  if (response.status !== 'OK') throw new Error(response.message || 'Failed to move service');
+
+  log('success', `Service moved to project ${targetProjectId}`);
+  return response;
+}
+
+export async function showService(vmID, projectId = null, json = false) {
+  const config = loadConfig();
+  const pid = projectId || config.defaultProject;
+
+  const details = await getServiceDetails(vmID, pid);
+  if (!details) throw new Error(`Service with vmID ${vmID} not found`);
+
+  if (json) {
+    outputJson(details);
+    return details;
+  }
+
+  console.log('\n' + formatService(details));
+  console.log(`\n${colors.bold}Extended Details${colors.reset}`);
+  console.log(`  Server ID: ${details.id || 'N/A'}`);
+  console.log(`  Firewall: ${details.isFirewallActivated ? 'enabled' : 'disabled'}`);
+  console.log(`  Alerts: ${details.isAlertsActivated ? 'enabled' : 'disabled'}`);
+  console.log(`  Remote Backup: ${details.remoteBackupsActivated ? 'enabled' : 'disabled'}`);
+  console.log(`  System Auto-Update: ${details.system_AutoUpdate_Enabled ? 'enabled' : 'disabled'}`);
+  console.log(`  App Auto-Update: ${details.app_AutoUpdate_Enabled ? 'enabled' : 'disabled'}`);
+  console.log(`  Price/Hour: $${details.pricePerHour || 'N/A'}`);
+  console.log('');
+  return details;
+}

package/src/commands/templates.js

@@ -0,0 +1,188 @@
+import { apiRequestNoAuth } from '../api.js';
+import { formatTable, colors, truncate, outputJson } from '../utils.js';
+
+let templatesCache = null;
+let sizesCache = null;
+
+export async function getTemplates() {
+  if (templatesCache) return templatesCache;
+  const response = await apiRequestNoAuth('/api/servers/getTemplates');
+  templatesCache = response.instances || [];
+  return templatesCache;
+}
+
+export async function searchTemplates(query, category = null) {
+  const templates = await getTemplates();
+  const q = query?.toLowerCase() || '';
+
+  return templates.filter(t => {
+    const matchesQuery = !q ||
+      t.title?.toLowerCase().includes(q) ||
+      t.description?.toLowerCase().includes(q);
+    const matchesCategory = !category ||
+      t.category?.toLowerCase().includes(category.toLowerCase());
+    return matchesQuery && matchesCategory;
+  });
+}
+
+const TEMPLATE_ALIASES = {
+  'cicd': 'CI-CD-Target',
+  'ci-cd': 'CI-CD-Target',
+  'postgres': 'PostgreSQL',
+  'pg': 'PostgreSQL',
+  'mysql': 'MySQL',
+  'mariadb': 'MariaDB',
+  'mongo': 'MongoDB',
+  'mongodb': 'MongoDB',
+  'elastic': 'Elasticsearch',
+  'elasticsearch': 'Elasticsearch',
+  'wp': 'Wordpress',
+  'wordpress': 'Wordpress',
+  'k8s': 'K3S',
+  'kubernetes': 'K3S'
+};
+
+export async function findTemplate(nameOrId) {
+  const templates = await getTemplates();
+
+  const byId = templates.find(t => String(t.id) === String(nameOrId));
+  if (byId) return byId;
+
+  const aliasedName = TEMPLATE_ALIASES[nameOrId?.toLowerCase()];
+  if (aliasedName) {
+    const byAlias = templates.find(t => t.title?.toLowerCase() === aliasedName.toLowerCase());
+    if (byAlias) return byAlias;
+  }
+
+  const byTitle = templates.find(t => t.title?.toLowerCase() === nameOrId?.toLowerCase());
+  if (byTitle) return byTitle;
+
+  return templates.find(t => t.title?.toLowerCase().includes(nameOrId?.toLowerCase()));
+}
+
+export async function listTemplates(category = null, json = false) {
+  const templates = category
+    ? await searchTemplates(null, category)
+    : await getTemplates();
+
+  if (json) {
+    outputJson(templates.map(t => ({ id: t.id, title: t.title, category: t.category, version: t.version || 'latest' })));
+    return;
+  }
+
+  const columns = [
+    { key: 'id', label: 'ID' },
+    { key: 'title', label: 'Name' },
+    { key: 'category', label: 'Category' },
+    { key: 'version', label: 'Version' }
+  ];
+
+  const data = templates.map(t => ({
+    id: t.id,
+    title: t.title,
+    category: truncate(t.category, 25),
+    version: t.version || 'latest'
+  }));
+
+  console.log(`\n${colors.bold}Templates (${templates.length})${colors.reset}\n`);
+  console.log(formatTable(data, columns));
+  console.log('');
+}
+
+export async function getServerSizes() {
+  if (sizesCache) return sizesCache;
+  const response = await apiRequestNoAuth('/api/servers/getServerSizes');
+  sizesCache = response.instances || [];
+  return sizesCache;
+}
+
+export async function filterSizes(provider = null, country = null) {
+  const sizes = await getServerSizes();
+  return sizes.filter(s => {
+    const matchesProvider = !provider || s.providerName?.toLowerCase() === provider.toLowerCase();
+    const matchesCountry = !country ||
+      s.Country?.toLowerCase().includes(country.toLowerCase()) ||
+      s.CountryCode?.toLowerCase() === country.toLowerCase();
+    return matchesProvider && matchesCountry;
+  });
+}
+
+export async function validateCombo(provider, datacenter, serverType) {
+  const sizes = await getServerSizes();
+  return sizes.find(s =>
+    s.providerName?.toLowerCase() === provider?.toLowerCase() &&
+    s.regionID?.toLowerCase() === datacenter?.toLowerCase() &&
+    s.title?.toLowerCase() === serverType?.toLowerCase()
+  );
+}
+
+export async function listSizes(provider = null, country = null, json = false) {
+  const sizes = await filterSizes(provider, country);
+
+  if (json) {
+    outputJson(sizes.map(s => ({
+      provider: s.providerName,
+      region: s.regionID,
+      location: `${s.City}, ${s.CountryCode}`,
+      size: s.title,
+      cpu: s.vCPU,
+      ramGB: s.ramGB,
+      storageGB: s.storageSizeGB,
+      pricePerHour: s.pricePerHour,
+      priceMonthly: (parseFloat(s.pricePerHour) * 24 * 30).toFixed(0)
+    })));
+    return;
+  }
+
+  const byProvider = {};
+  sizes.forEach(s => {
+    if (!byProvider[s.providerName]) byProvider[s.providerName] = [];
+    byProvider[s.providerName].push(s);
+  });
+
+  console.log(`\n${colors.bold}Server Sizes (${sizes.length} options)${colors.reset}\n`);
+
+  Object.entries(byProvider).forEach(([providerName, providerSizes]) => {
+    console.log(`${colors.cyan}${providerName}${colors.reset}`);
+
+    const columns = [
+      { key: 'regionID', label: 'Region' },
+      { key: 'location', label: 'Location' },
+      { key: 'title', label: 'Size' },
+      { key: 'vCPU', label: 'CPU' },
+      { key: 'ramGB', label: 'RAM' },
+      { key: 'storage', label: 'Storage' },
+      { key: 'price', label: 'Price/mo' }
+    ];
+
+    const data = providerSizes.slice(0, 20).map(s => ({
+      regionID: s.regionID,
+      location: `${s.City}, ${s.CountryCode}`,
+      title: s.title,
+      vCPU: s.vCPU,
+      ramGB: s.ramGB + 'GB',
+      storage: s.storageSizeGB + 'GB ' + (s.storageType || ''),
+      price: '$' + (parseFloat(s.pricePerHour) * 24 * 30).toFixed(0)
+    }));
+
+    console.log(formatTable(data, columns));
+    if (providerSizes.length > 20) {
+      console.log(`  ... and ${providerSizes.length - 20} more`);
+    }
+    console.log('');
+  });
+}
+
+export async function listCategories(json = false) {
+  const templates = await getTemplates();
+  const categories = [...new Set(templates.map(t => t.category))].filter(Boolean).sort();
+
+  if (json) {
+    outputJson(categories);
+    return;
+  }
+
+  console.log(`\n${colors.bold}Template Categories${colors.reset}\n`);
+  categories.forEach(c => console.log(`  ${c}`));
+  console.log('');
+}

package/src/commands/volumes.js

@@ -0,0 +1,117 @@
+import { apiRequest } from '../api.js';
+import { loadConfig } from '../config.js';
+import { doAction } from './actions.js';
+import { log, colors, formatTable, outputJson } from '../utils.js';
+
+export async function listVolumes(projectId = null, json = false) {
+  const config = loadConfig();
+  const pid = projectId || config.defaultProject;
+  if (!pid) throw new Error('Project ID required');
+
+  const response = await apiRequest('/api/volumes/getVolumes', 'POST', { projectID: String(pid) });
+  if (response.status !== 'OK') throw new Error(response.message || 'Failed to list volumes');
+
+  const volumes = response.data?.volumes || [];
+
+  if (json) { outputJson(volumes); return volumes; }
+  if (volumes.length === 0) { log('info', `No volumes in project ${pid}`); return []; }
+
+  const columns = [
+    { key: 'id', label: 'ID' },
+    { key: 'name', label: 'Name' },
+    { key: 'size', label: 'Size' },
+    { key: 'provider', label: 'Provider' },
+    { key: 'region', label: 'Region' },
+    { key: 'attached', label: 'Attached' }
+  ];
+
+  const data = volumes.map(v => ({
+    id: v.volumeID || v.id,
+    name: v.volumeName || v.name,
+    size: (v.volume || v.size) + 'GB',
+    provider: v.providerName || v.provider,
+    region: v.datacenter || v.region,
+    attached: v.serverID ? 'Yes' : 'No'
+  }));
+
+  console.log(`\n${colors.bold}Volumes (${volumes.length})${colors.reset}\n`);
+  console.log(formatTable(data, columns));
+  console.log('');
+  return volumes;
+}
+
+export async function createVolume(options = {}) {
+  const config = loadConfig();
+  const { name, size = 10, provider = config.defaults?.provider || 'hetzner', datacenter = config.defaults?.datacenter || 'fsn1', projectId = config.defaultProject, serverId = null, storageType = 'NVME' } = options;
+
+  if (!name) throw new Error('Volume name required');
+  if (!projectId) throw new Error('Project ID required');
+
+  const price = (size * 0.05).toFixed(2);
+  log('info', `Creating volume "${name}" (${size}GB ${storageType} @ ${provider}/${datacenter})...`);
+
+  const body = {
+    projectID: String(projectId), providerName: provider, datacenter,
+    volumeName: name, price, isMoveData: false, volume: size, blockStorageType: storageType
+  };
+  if (serverId) body.selectedServerID = String(serverId);
+
+  const response = await apiRequest('/api/volumes/createVolume', 'POST', body);
+  if (response.status !== 'OK' && !response.volumeID) throw new Error(response.message || 'Failed to create volume');
+
+  log('success', `Volume "${name}" created`);
+  return response;
+}
+
+export async function getServiceVolumes(vmID, json = false) {
+  const result = await doAction(vmID, 'getServiceVolume');
+  const volumes = Array.isArray(result.data) ? result.data : (result.data?.volumes || result.volumes || []);
+
+  if (json) { outputJson(volumes); return volumes; }
+  if (volumes.length === 0) { log('info', 'No volumes attached'); return []; }
+
+  console.log(`\n${colors.bold}Attached Volumes${colors.reset}\n`);
+  volumes.forEach(v => console.log(`  ${v.volumeID || v.id}: ${v.volumeName || v.name} (${v.volumeSizeInGB || v.volume || v.size || 'N/A'}GB)`));
+  console.log('');
+  return volumes;
+}
+
+export async function createServiceVolume(vmID, options = {}) {
+  const { name, size = 10, storageType = 'NVME' } = options;
+  if (!name) throw new Error('Volume name required');
+
+  log('info', `Creating and attaching volume "${name}" to ${vmID}...`);
+  const result = await doAction(vmID, 'createServiceVolume', { volumeName: name, volume: size, blockStorageType: storageType, isMoveData: false });
+  log('success', `Volume "${name}" created and attached`);
+  return result;
+}
+
+export async function resizeVolume(vmID, volumeID, newSize) {
+  if (!newSize || newSize < 10) throw new Error('New size must be at least 10GB');
+  log('info', `Resizing volume ${volumeID} to ${newSize}GB...`);
+  const result = await doAction(vmID, 'resizeServiceVolume', { volumeID: String(volumeID), volume: newSize, volumeName: '', isMoveData: false, currentSize: 0 });
+  log('success', `Volume resized to ${newSize}GB`);
+  return result;
+}
+
+export async function detachVolume(vmID, volumeID, options = {}) {
+  const { keepVolume = true } = options;
+  log('info', `Detaching volume ${volumeID} from ${vmID}...`);
+  const result = await doAction(vmID, 'detachServiceVolume', { volumeID: String(volumeID), isKeepVolume: keepVolume, isMoveData: false });
+  log('success', `Volume detached${keepVolume ? '' : ' and deleted'}`);
+  return result;
+}
+
+export async function deleteServiceVolume(vmID, volumeID) {
+  log('info', `Deleting volume ${volumeID}...`);
+  const result = await doAction(vmID, 'deleteServiceVolume', { volumeID: String(volumeID) });
+  log('success', 'Volume deleted');
+  return result;
+}
+
+export async function setVolumeProtection(vmID, volumeID, enabled = true) {
+  log('info', `${enabled ? 'Enabling' : 'Disabling'} protection for volume ${volumeID}...`);
+  const result = await doAction(vmID, 'manageServiceVolumeProtection', { volumeID: String(volumeID), isVolumeProtection: enabled });
+  log('success', `Volume protection ${enabled ? 'enabled' : 'disabled'}`);
+  return result;
+}

package/src/config.js

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const ELESTIO_DIR = path.join(os.homedir(), '.elestio');
+const CREDENTIALS_PATH = path.join(ELESTIO_DIR, 'credentials');
+const CONFIG_PATH = path.join(ELESTIO_DIR, 'config.json');
+
+const DEFAULT_CONFIG = {
+  jwt: null,
+  jwtExpiry: null,
+  defaultProject: null,
+  defaults: {
+    provider: 'netcup',
+    datacenter: 'nbg',
+    serverType: 'MEDIUM-2C-4G',
+    support: 'level1'
+  }
+};
+
+function ensureDir() {
+  if (!fs.existsSync(ELESTIO_DIR)) {
+    fs.mkdirSync(ELESTIO_DIR, { mode: 0o700, recursive: true });
+  }
+}
+
+// ── Credentials (email + apiToken) ──
+
+export function getCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_PATH)) {
+      const data = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf-8'));
+      return {
+        email: data.email || null,
+        apiToken: data.apiToken || null
+      };
+    }
+  } catch {
+    // ignore
+  }
+  return { email: null, apiToken: null };
+}
+
+export function saveCredentials(email, apiToken) {
+  ensureDir();
+  fs.writeFileSync(
+    CREDENTIALS_PATH,
+    JSON.stringify({ email, apiToken }, null, 2),
+    { mode: 0o600 }
+  );
+}
+
+// ── Config (jwt, defaults, defaultProject) ──
+
+export function loadConfig() {
+  let config = { ...DEFAULT_CONFIG };
+
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+      config = { ...DEFAULT_CONFIG, ...data };
+    }
+  } catch {
+    // ignore
+  }
+
+  // Merge credentials into config for convenience
+  const creds = getCredentials();
+  config.email = creds.email;
+  config.apiToken = creds.apiToken;
+
+  return config;
+}
+
+export function saveConfig(config) {
+  ensureDir();
+  // Never persist credentials in config.json
+  const { email, apiToken, ...safeConfig } = config;
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(safeConfig, null, 2));
+}
+
+// ── Exports ──
+
+export { ELESTIO_DIR, CREDENTIALS_PATH, CONFIG_PATH };