elestio 1.2.3 → 1.3.1

package/README.md

@@ -249,7 +249,7 @@ replica.
 | `elestio backups remote-list <vmID>` | List remote backups |
 | `elestio backups remote-take <vmID>` | Take remote backup |
 | `elestio backups remote-restore <vmID> <snapshot>` | Restore remote backup |
-| `elestio backups auto-enable <vmID>` | Setup auto backups |
+| `elestio backups auto-enable <vmID> [--path /opt] [--hour 03:00]` | Setup auto backups of a directory on the VM (default `/opt`) |
 | `elestio backups auto-disable <vmID>` | Disable auto backups |
 
 ### Snapshots
@@ -345,17 +345,24 @@ written as `random_password` are generated, `[EMAIL]` becomes your account
 email, and `[CI_CD_DOMAIN]` is resolved by the platform once the pipeline has a
 domain.
 
-**Two routes:**
+**Three routes. The default needs nothing from you:**
 
-| | compose (default) | git (`--owner <git-user>`) |
-|---|---|---|
-| What it does | Inlines the template's `docker-compose.yml` | Generates the template repo into your Git account, then builds from it |
-| Needs a Git account | No | Yes, connected in the dashboard |
-| Lifecycle scripts | Skipped | Run |
-| Repo files the compose mounts | Unavailable | Available |
-| Works for | Templates that need no files from the repo | Every template |
+| | repo (default) | inline (`--inline-compose`) | git (`--owner <git-user>`) |
+|---|---|---|---|
+| What it does | Points the pipeline at the `elestio-examples` repo, which Elestio clones on the VM | Inlines the template's `docker-compose.yml` only | Generates the template repo into your Git account, then builds from it |
+| Needs a Git account | No | No | Yes, connected in the dashboard |
+| Install scripts | **Run** | Skipped | Run |
+| Files the compose mounts or reads | **Present** | Missing | Present |
+| Works for | The whole catalogue | Templates that need no file from the repo | Every template |
+
+The default route sends `imageData.dockerExample` (the template repo URL),
+`branch` and `repoName`. The backend stores them as the pipeline's
+`gitConfig.repoURL`, and the deployment agent clones that repo with Elestio's
+own Git token - the same thing the dashboard does. Nothing is copied into your
+account, and no Git account is needed.
 
-The compose route has no checkout and runs no install script, so a template
+`--inline-compose` sends only the compose file, which is what you want for a
+compose of your own. That route has no checkout and runs no install script, so a template
 whose `docker-compose.yml` bind-mounts a file cannot work: Docker creates the
 missing source as an empty directory and the container fails to start. The file
 may ship in the template repo (n8n's `./n8n-task-runners.json`) or be generated

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elestio",
-  "version": "1.2.3",
+  "version": "1.3.1",
   "description": "Elestio CLI - Deploy and manage services on the Elestio DevOps platform",
   "type": "module",
   "main": "src/cli.js",

package/src/commands/backups.js

@@ -83,8 +83,13 @@ export async function restoreRemoteBackup(vmID, snapshotName) {
   return response;
 }
 
-export async function setupAutoBackups(vmID, backupPath = '/backup/', backupHour = '03:00') {
-  log('info', `Setting up auto backups for ${vmID}...`);
+// Directory the backend hands to `borg create` on the VM. It must exist there,
+// or every archive is empty. /opt holds the app stack; the dashboard sends it.
+export const DEFAULT_BACKUP_PATH = '/opt';
+
+export async function setupAutoBackups(vmID, backupPath = DEFAULT_BACKUP_PATH, backupHour = '03:00') {
+  if (!backupPath.startsWith('/')) throw new Error(`Backup path must be absolute, got "${backupPath}"`);
+  log('info', `Setting up auto backups for ${vmID} (${backupPath})...`);
   const response = await apiRequest('/api/backups/SetupAutoBackups', 'POST', { serverID: String(vmID), backupPath, backupHour });
   if (response.status !== 'OK') throw new Error(response.message || 'Failed to setup');
   log('success', `Auto backups configured at ${backupHour}`);

package/src/commands/cicd-template.js

@@ -3,7 +3,7 @@ import { loadConfig } from '../config.js';
 import { log, colors, outputJson, formatTable } from '../utils.js';
 import { getTemplates } from './templates.js';
 import { createSubstitutions, normalizeElestioConfig, repoFileMounts } from '../templates/elestio-config.js';
-import { buildGitPipelinePayload, buildComposePipelinePayload } from '../payloads/pipeline.js';
+import { buildGitPipelinePayload, buildComposePipelinePayload, buildTemplateRepoPipelinePayload } from '../payloads/pipeline.js';
 import { parseGitAuthId } from './cicd.js';
 import { TEMPLATE_REPO_OWNER, TEMPLATE_REPO_HOST } from '../constants.js';
 
@@ -16,11 +16,18 @@ import { TEMPLATE_REPO_OWNER, TEMPLATE_REPO_HOST } from '../constants.js';
  * produces a pipeline that starts nothing, which is why this is a dedicated
  * command rather than a flag on `cicd create`.
  *
- * Two routes:
- *   git     - generate the template repo into the user's own Git account, then
- *             point the pipeline at it. Keeps the lifecycle scripts.
- *   compose - inline the template's docker-compose.yml. No Git account needed,
- *             but lifecycle scripts are lost because there is no checkout.
+ * Three routes:
+ *   repo (default) - point the pipeline at the elestio-examples repo itself.
+ *             Elestio clones it on the VM with its own Git token, so the repo's
+ *             files exist and its install scripts run. No Git account needed,
+ *             nothing copied into the user's account. This is what the
+ *             dashboard does.
+ *   inline  - inline the docker-compose.yml only (--inline-compose). No
+ *             checkout: install scripts are skipped and any file the compose
+ *             mounts or reads (env_file) is missing. Half the catalogue cannot
+ *             work this way.
+ *   git     - generate the template repo into the user's own Git account
+ *             (--owner). Needs an endpoint the API does not expose (404).
  */
 
 function templateRepoUrl(repoName) {
@@ -208,13 +215,16 @@ export async function deployTemplate(nameOrId, options = {}) {
   }
   log('success', `Config loaded: runtime "${elestioConfig.config.runTime}", ${elestioConfig.variables ? elestioConfig.variables.split('\n').length : 0} env vars, ${elestioConfig.ports.length} port(s)`);
 
-  const payload = useGit
+  const route = useGit ? 'git' : (options.inlineCompose ? 'inline' : 'repo');
+  const payload = route === 'git'
     ? await buildGitRoute({ options, projectId, target, template, repoName, pipelineName, branch, elestioConfig, dryRun: !!options.dryRun })
-    : await buildComposeRoute({ projectId, target, repoName, pipelineName, branch, sourceRepoUrl, elestioConfig, force: options.force });
+    : route === 'inline'
+      ? await buildComposeRoute({ projectId, target, repoName, pipelineName, branch, sourceRepoUrl, elestioConfig, force: options.force })
+      : await buildTemplateRepoRoute({ projectId, target, repoName, pipelineName, branch, sourceRepoUrl, elestioConfig });
 
   if (options.dryRun) {
-    if (options.json) { outputJson({ dryRun: true, route: useGit ? 'git' : 'compose', payload }); return payload; }
-    printPlan({ template, repoName, pipelineName, target, elestioConfig, useGit, branch });
+    if (options.json) { outputJson({ dryRun: true, route, payload }); return payload; }
+    printPlan({ template, repoName, pipelineName, target, elestioConfig, route, branch });
     log('info', 'To deploy, run the same command without --dry-run');
     return payload;
   }
@@ -229,7 +239,7 @@ export async function deployTemplate(nameOrId, options = {}) {
   log('success', `Pipeline "${pipelineName}" created on ${target.displayName}`);
 
   if (options.json) {
-    outputJson({ status: 'OK', pipelineName, target: target.vmID, route: useGit ? 'git' : 'compose', webUI: elestioConfig.webUI, response });
+    outputJson({ status: 'OK', pipelineName, target: target.vmID, route, webUI: elestioConfig.webUI, response });
     return response;
   }
 
@@ -286,6 +296,22 @@ async function buildGitRoute({ options, projectId, target, template, repoName, p
   });
 }
 
+/**
+ * Default route: the pipeline points at the template repo, which Elestio clones
+ * on the VM. Nothing to refuse -- the repo's files are there and its install
+ * scripts run.
+ */
+async function buildTemplateRepoRoute({ projectId, target, repoName, pipelineName, branch, sourceRepoUrl, elestioConfig }) {
+  log('info', `Fetching docker-compose from ${TEMPLATE_REPO_OWNER}/${repoName}...`);
+  const compose = await fetchCompose(sourceRepoUrl, branch, projectId);
+  log('success', 'Compose file loaded');
+
+  const hooks = installHooks(elestioConfig);
+  if (hooks.length > 0) log('info', `Install scripts run from the cloned repo: ${hooks.join(', ')}`);
+
+  return buildTemplateRepoPipelinePayload({ target, projectId, pipelineName, compose, repoName, branch, elestioConfig });
+}
+
 async function buildComposeRoute({ projectId, target, repoName, pipelineName, branch, sourceRepoUrl, elestioConfig, force }) {
   log('info', `Fetching docker-compose from ${TEMPLATE_REPO_OWNER}/${repoName}...`);
   const compose = await fetchCompose(sourceRepoUrl, branch, projectId);
@@ -346,13 +372,18 @@ function collectOverrides(options) {
   return overrides;
 }
 
-function printPlan({ template, repoName, pipelineName, target, elestioConfig, useGit, branch }) {
+function printPlan({ template, repoName, pipelineName, target, elestioConfig, route, branch }) {
   console.log(`\n${colors.bold}Pipeline Preview (--dry-run)${colors.reset}\n`);
   console.log(`  Software:   ${colors.cyan}${template.title}${colors.reset} (ID: ${template.id})`);
   console.log(`  Template:   ${TEMPLATE_REPO_OWNER}/${repoName} @ ${branch}`);
   console.log(`  Pipeline:   ${pipelineName}`);
   console.log(`  Target:     ${target.displayName} (${target.vmID})`);
-  console.log(`  Route:      ${useGit ? 'git (repo generated in your account, lifecycle scripts kept)' : 'compose (inlined, lifecycle scripts skipped)'}`);
+  const routes = {
+    repo: 'repo (Elestio clones the template repo on the VM, install scripts run)',
+    inline: 'inline compose (no checkout: install scripts skipped, mounted files missing)',
+    git: 'git (repo generated in your account, install scripts run)'
+  };
+  console.log(`  Route:      ${routes[route]}`);
   console.log(`  Runtime:    ${elestioConfig.config.runTime || 'N/A'}`);
   console.log(`  Ports:      ${elestioConfig.ports.map(p => `${p.listeningPort}->${p.targetPort}`).join(', ') || 'default'}`);
   console.log(`  Env vars:   ${elestioConfig.variables ? elestioConfig.variables.split('\n').map(v => v.split('=')[0]).join(', ') : 'none'}`);

package/src/payloads/pipeline.js

@@ -1,4 +1,4 @@
-import { RUNTIME_PRESETS } from '../constants.js';
+import { RUNTIME_PRESETS, TEMPLATE_REPO_OWNER, TEMPLATE_REPO_HOST } from '../constants.js';
 import { EMPTY_LIFECYCLE } from '../templates/elestio-config.js';
 
 /**
@@ -147,6 +147,55 @@ export function buildGitPipelinePayload({
   });
 }
 
+/**
+ * Pipeline running catalog software from its own template repo.
+ *
+ * This is what the dashboard sends: `imageData.dockerExample` carries the
+ * elestio-examples URL, and the backend then stores it as the pipeline's
+ * gitConfig.repoURL (createCiCdExistServer). The deployment agent clones that
+ * repo on the VM with Elestio's own Git token, so the repo's files exist and
+ * its lifecycle scripts run -- without copying anything into the user's Git
+ * account, and without needing a connected Git account at all.
+ *
+ * The inline route below cannot do either, which is why half the catalogue
+ * (Kafka, Chromadb, Weaviate, ClickHouse, WordPress...) is undeployable
+ * through it.
+ */
+export function buildTemplateRepoPipelinePayload({
+  target, projectId, pipelineName, compose, repoName, branch = 'main', elestioConfig, overrides = {}
+}) {
+  if (!compose) throw new Error('A docker-compose file is required');
+  if (!repoName) throw new Error('A template repo name is required');
+  const fromFile = elestioConfig && elestioConfig.hasConfig ? elestioConfig : null;
+
+  return buildPipelinePayload({
+    target, projectId, pipelineName,
+    cicdMode: 'DockerCompose',
+    gitData: {},
+    imageData: {
+      isPrivate: false,
+      compose,
+      // The three fields that turn this into a cloned-repo pipeline.
+      dockerExample: `${TEMPLATE_REPO_HOST}/${TEMPLATE_REPO_OWNER}/${repoName}`,
+      branch,
+      repoName
+    },
+    configData: {
+      runTime: 'NodeJs', framework: 'NoFramework', version: '20',
+      buildDir: '/', rootDir: '/', buildCmd: '', runCmd: '', installCmd: ''
+    },
+    ports: overrides.ports || fromFile?.ports,
+    exposedPorts: overrides.exposedPorts || fromFile?.exposedPorts,
+    variables: overrides.variables ?? fromFile?.variables ?? '',
+    // Kept, unlike the inline route: the repo is checked out, so they can run.
+    lifeCycleCommand: fromFile?.lifeCycleCommand,
+    copyCommandConfig: fromFile?.copyCommandConfig || [],
+    authID: null,
+    isPublicGitRepo: false,
+    isNeedToCreateRepo: false
+  });
+}
+
 /**
  * Pipeline running an inline docker-compose file, with no Git repo attached.
  *

package/src/registry.js

@@ -504,7 +504,7 @@ export const registry = {
       'remote-list': { summary: 'List remote backups', usage: 'remote-list <vmID>', async run({ args, json }) { await (await load.backups()).listRemoteBackups(requireArg(args._[2], 'backups remote-list <vmID>'), json); } },
       'remote-take': { summary: 'Take a remote backup', usage: 'remote-take <vmID>', async run({ args }) { await (await load.backups()).takeRemoteBackup(requireArg(args._[2], 'backups remote-take <vmID>')); } },
       'remote-restore': { summary: 'Restore a remote backup', usage: 'remote-restore <vmID> <snapshot>', async run({ args }) { await (await load.backups()).restoreRemoteBackup(requireArg(args._[2], 'backups remote-restore <vmID> <snapshot>'), positional(args, 3, 'snapshot')); } },
-      'auto-enable': { summary: 'Enable scheduled backups (--path, --hour)', usage: 'auto-enable <vmID>', async run({ args }) { await (await load.backups()).setupAutoBackups(requireArg(args._[2], 'backups auto-enable <vmID>'), args.path, args.hour); } },
+      'auto-enable': { summary: 'Enable scheduled backups (--path dir on the VM, default /opt; --hour)', usage: 'auto-enable <vmID>', async run({ args }) { await (await load.backups()).setupAutoBackups(requireArg(args._[2], 'backups auto-enable <vmID>'), args.path, args.hour); } },
       'auto-disable': { summary: 'Disable scheduled backups', usage: 'auto-disable <vmID>', async run({ args }) { await (await load.backups()).disableAutoBackups(requireArg(args._[2], 'backups auto-disable <vmID>')); } }
     }
   },
@@ -632,6 +632,7 @@ export const registry = {
             owner: args.owner, branch: args.branch, repoName: args['repo-name'],
             gitType: args['git-type'], authId: args['auth-id'],
             git: !args['no-git'] && (args.git === true || args.git === 'true' || !!args.owner),
+            inlineCompose: !!args['inline-compose'],
             private: !!args.private, nonOrg: !!args['non-org'],
             buildCmd: args['build-cmd'], runCmd: args['run-cmd'],
             installCmd: args['install-cmd'], buildDir: args['build-dir'],

package/src/templates/elestio-config.js

@@ -185,8 +185,6 @@ export function repoFileMounts(compose) {
   };
 
   // Short syntax, quoted or not: - ./file:/in/container[:ro]
-  // Many templates quote their mounts (Chromadb among them), and the
-  // unquoted-only pattern let those through silently.
   for (const match of compose.matchAll(/^\s*-\s+["']?(\.{1,2}\/[^\s:"']+)["']?\s*:/gm)) {
     add(match[1]);
   }
@@ -196,5 +194,19 @@ export function repoFileMounts(compose) {
     add(match[1]);
   }
 
+  // env_file, inline or as a list. Docker refuses to start when the file is
+  // missing, and 8 of the 22 catalogue templates sampled read one.
+  for (const match of compose.matchAll(/^\s*env_file:\s*(?:\[([^\]]*)\]|["']?([^\s"'\[]+)["']?)\s*$/gm)) {
+    for (const entry of (match[1] ?? match[2] ?? '').split(',')) {
+      const file = entry.trim().replace(/^["']|["']$/g, '');
+      if (file.startsWith('.')) add(file);
+    }
+  }
+  for (const block of compose.matchAll(/^\s*env_file:\s*$((?:\n\s*-\s+.*)+)/gm)) {
+    for (const item of block[1].matchAll(/^\s*-\s+["']?([^\s"']+)["']?\s*$/gm)) {
+      if (item[1].startsWith('.')) add(item[1]);
+    }
+  }
+
   return [...mounts];
 }