@nitsan-ai/ragsuite-test 0.1.2 → 0.1.4

package/src/commands/update.js

@@ -2,86 +2,119 @@
 
 const fs = require('fs');
 const path = require('path');
-const { resolveRepoRoot } = require('../utils/paths');
+const { resolveRepoRoot, isImagesInstall, looksLikeGitCheckout } = require('../utils/paths');
 const { readConfig } = require('../utils/config');
-const { captureCommand } = require('../utils/spawn');
-const { info, warn } = require('../utils/log');
+const { setActiveInstall } = require('../utils/global-config');
+const { captureCommand, runScript } = require('../utils/spawn');
+const { info, warn, error } = require('../utils/log');
 
 const name = 'update';
-const summary = 'Verify install path and print safe update steps';
+const summary = 'Update app in place (git pull or image pull) — keeps data & .env';
 
 function help() {
-  return `Usage: ragsuite-test update [options]
+  return `Usage: ragsuite-test update
 
-Verifies the install/repo path and prints safe update steps.
-Git installs: git fetch + pull guidance (no destructive reset).
+Upgrades the active install without wiping data:
+  • Git install  → git pull (keeps .env + Docker volumes)
+  • Images install → docker compose pull (keeps .env + volumes)
 
 Never runs docker compose down -v.
 
+Typical flow after a new release:
+  npm install -g @nitsan-ai/ragsuite-test@latest
+  ragsuite-test update
+  ragsuite-test start
+
 Options:
-  --repo-root <path>       Monorepo / install root
+  --repo-root <path>       Override active install
+  --dry-run                Print actions only
 `;
 }
 
 function run(ctx) {
-  const repoRoot = resolveRepoRoot({
-    cwd: ctx.cwd,
-    repoRootFlag: ctx.globals.repoRoot,
-    env: ctx.env,
-  });
+  let repoRoot;
+  try {
+    repoRoot = resolveRepoRoot({
+      cwd: ctx.cwd,
+      repoRootFlag: ctx.globals.repoRoot,
+      env: ctx.env,
+    });
+  } catch (err) {
+    error(err.message);
+    return 1;
+  }
 
+  setActiveInstall(repoRoot);
   const cfg = readConfig(repoRoot);
-  const source = (cfg && cfg.source) || 'checkout';
+  const source = (cfg && cfg.source) || (isImagesInstall(repoRoot) ? 'images' : 'git');
+  const images = source === 'images' || isImagesInstall(repoRoot);
 
-  info(`Install path OK: ${repoRoot}`);
+  info(`Updating install: ${repoRoot}`);
   info(`  source=${source}`);
+  info('  (.env and Docker volumes are kept — never wiped)');
   info('');
 
-  info('Safe update steps:');
-  info('  1. Stop the stack (ragsuite-test stop --repo-root …)');
-  info('  2. Update sources (git pull)');
-  info('  3. Docker: npm run rebuild or docker compose build');
-  info('  4. Native: re-run backend/scripts/setup.sh if Python deps changed');
-  info('  5. Start again (ragsuite-test start --repo-root …)');
-  info('  6. Run doctor after upgrades');
-  info('');
-  info('Never: docker compose down -v (destroys Postgres/Chroma data).');
-  info('');
-
-  const gitDir = path.join(repoRoot, '.git');
-  if (!fs.existsSync(gitDir)) {
-    warn('No .git directory — skip fetch/status. Re-init with --from-git if needed.');
+  if (ctx.globals.dryRun) {
+    info(`[dry-run] would update ${images ? 'images (compose pull)' : 'git (pull)'}`);
     return 0;
   }
 
-  const remote = captureCommand('git', ['remote', '-v'], { cwd: repoRoot, env: ctx.env });
-  if (remote.status !== 0 || !String(remote.stdout || '').trim()) {
-    warn('No git remote configured — skip fetch.');
-    return 0;
+  if (images) {
+    info('Pulling newer Docker images…');
+    const pull = captureCommand(
+      'docker',
+      ['compose', '-f', 'docker-compose.yml', 'pull'],
+      { cwd: repoRoot, env: ctx.env },
+    );
+    if (pull.status !== 0) {
+      error(`Image pull failed (exit ${pull.status}).`);
+      if (pull.stderr) error(String(pull.stderr).trimEnd());
+      error('Publish GHCR images / check IMAGE_TAG in .env, then retry.');
+      return 1;
+    }
+    info('Images pulled.');
+    info('');
+    info('Apply update:');
+    info('  ragsuite-test stop');
+    info('  ragsuite-test start');
+    info('(or: ragsuite-test start — compose recreate with new images)');
+    // Recreate containers with new images without wiping volumes
+    info('');
+    info('Recreating containers with new images (volumes preserved)…');
+    return runScript(repoRoot, path.join('scripts', 'docker-start-images.sh'), ['--detach'], {
+      dryRun: false,
+      env: { ...ctx.env, RAGSUITE_MODE: 'docker' },
+    });
   }
 
-  info('Git remotes:');
-  info(String(remote.stdout).trimEnd());
-  info('');
-  info('Running git fetch (non-destructive)…');
-  const fetch = captureCommand('git', ['fetch', '--all', '--prune'], {
+  // Git / checkout install
+  if (!looksLikeGitCheckout(repoRoot) && !fs.existsSync(path.join(repoRoot, '.git'))) {
+    error('This install has no .git directory. Re-run: ragsuite-test init --force');
+    return 1;
+  }
+
+  info('Fetching and pulling latest from git (non-destructive)…');
+  const pull = captureCommand('git', ['pull', '--ff-only'], {
     cwd: repoRoot,
     env: ctx.env,
   });
-  if (fetch.status !== 0) {
-    warn(
-      `git fetch failed (exit ${fetch.status}). Private remotes need credentials. Continuing with status only.`,
-    );
-    if (fetch.stderr) warn(String(fetch.stderr).trimEnd());
-  } else {
-    info('git fetch OK');
-  }
-
-  const status = captureCommand('git', ['status', '-sb'], { cwd: repoRoot, env: ctx.env });
-  if (status.stdout) {
-    info('');
-    info(String(status.stdout).trimEnd());
+  if (pull.status !== 0) {
+    warn(`git pull --ff-only failed (exit ${pull.status}). Trying fetch + status…`);
+    if (pull.stderr) warn(String(pull.stderr).trimEnd());
+    captureCommand('git', ['fetch', '--all', '--prune'], { cwd: repoRoot, env: ctx.env });
+    const st = captureCommand('git', ['status', '-sb'], { cwd: repoRoot, env: ctx.env });
+    if (st.stdout) info(String(st.stdout).trimEnd());
+    error('Could not fast-forward. Fix local commits or stash, then: cd install && git pull');
+    return 1;
   }
+  if (pull.stdout) info(String(pull.stdout).trimEnd());
+  info('git pull OK.');
+  info('');
+  info('Restart to apply:');
+  info('  ragsuite-test stop');
+  info('  ragsuite-test start');
+  info('');
+  info('Never: docker compose down -v  (would delete Postgres/Chroma data)');
   return 0;
 }
 

package/src/index.js

@@ -31,8 +31,9 @@ function globalHelp() {
     'Global options:',
     '  --help, -h              Show help',
     '  --repo-root <path>      Monorepo / install root',
-    '  --from-git [url]        init: clone this URL (default: public nitsan-ai/RAGSUITE)',
-    '  --install-dir <path>    init: clone target (default ~/ragsuite-test)',
+    '  --from-git [url]        init: clone source (default public repo)',
+    '  --from-images           init: Docker images only (no app source on disk)',
+    '  --install-dir <path>    init: install target (default ~/ragsuite-test)',
     '  --llm-api-key <key>     init: optional override for CUSTOM_LLM_INTERNAL_API_KEY',
     '  --smtp-host <host>      init: optional SMTP override',
     '  --smtp-user <user>      init: optional SMTP override',
@@ -41,8 +42,9 @@ function globalHelp() {
     '  --force                 init: overwrite non-empty install dir / .env',
     '  --yes, -y               Non-interactive (same defaults as plain init)',
     '  --mode <docker|native>  Override config (Docker optional)',
-    '  --dry-run               Print actions without running (start/stop/doctor/logs)',
+    '  --dry-run               Print actions without running (start/stop/doctor/logs/update)',
     '',
+    'Active install: ~/.ragsuite-test/config.json (set by init; used by start/update/stop)',
     'Env: RAGSUITE_REPO_ROOT or RAGSUITE_INSTALL_DIR',
     '     RAGSUITE_TEST_LLM_API_KEY, RAGSUITE_TEST_SMTP_* , RAGSUITE_TEST_EMAIL_FROM',
     '',

package/src/utils/args.js

@@ -11,6 +11,7 @@ function parseArgv(argv) {
     dryRun: false,
     mode: null,
     fromGit: null,
+    fromImages: false,
     fromRelease: null,
     installDir: null,
     force: false,
@@ -79,6 +80,11 @@ function parseArgv(argv) {
       continue;
     }
 
+    if (t === '--from-images') {
+      globals.fromImages = true;
+      continue;
+    }
+
     if (t === '--from-git' || t.startsWith('--from-git=')) {
       if (t === '--from-git') {
         const next = tokens[i + 1];

package/src/utils/config.js

@@ -21,6 +21,12 @@ function defaultConfig(repoRoot, mode = 'docker') {
   };
 }
 
+function normalizeSource(raw) {
+  const s = String(raw || '').trim();
+  if (s === 'images' || s === 'git' || s === 'zip' || s === 'checkout') return s;
+  return 'checkout';
+}
+
 function readConfig(repoRoot) {
   const file = configPath(repoRoot);
   if (!fs.existsSync(file)) {
@@ -31,11 +37,10 @@ function readConfig(repoRoot) {
     if (!raw || typeof raw !== 'object') {
       return null;
     }
-    const source = raw.source === 'zip' ? 'zip' : 'checkout';
     return {
       version: Number(raw.version) || CONFIG_VERSION,
       mode: raw.mode === 'native' ? 'native' : 'docker',
-      source,
+      source: normalizeSource(raw.source),
       repoRoot: path.resolve(String(raw.repoRoot || repoRoot)),
       installDir: path.resolve(String(raw.installDir || raw.repoRoot || repoRoot)),
     };
@@ -48,10 +53,11 @@ function writeConfig(repoRoot, partial = {}) {
   const dir = path.join(repoRoot, CONFIG_DIR);
   fs.mkdirSync(dir, { recursive: true });
   const existing = readConfig(repoRoot) || defaultConfig(repoRoot);
-  const source =
-    partial.source === 'zip' || partial.source === 'checkout'
+  const source = normalizeSource(
+    partial.source !== undefined && partial.source !== null
       ? partial.source
-      : existing.source || 'checkout';
+      : existing.source || 'checkout',
+  );
   const next = {
     ...existing,
     ...partial,

package/src/utils/distribution.js

@@ -3,19 +3,21 @@
 /**
  * Distribution modes for the testing CLI.
  *
- * - git-clone: default `ragsuite-test init` (public GitHub)
- * - local-checkout: --repo-root (advanced / CI)
+ * - git-clone: `ragsuite-test init` (source on disk)
+ * - images: `ragsuite-test init --from-images` (pull GHCR, no app source)
+ * - local-checkout: --repo-root
  */
 
 const MODE_LOCAL = 'local-checkout';
 const MODE_GIT = 'git-clone';
+const MODE_IMAGES = 'images';
 const MODE_REGISTRY = 'registry-compose';
 
 function assertSupportedInstall() {}
 
 function resolveComposeBundle() {
   const err = new Error(
-    'Registry/compose (GHCR) install is not available yet. Run: ragsuite-test init',
+    'Use: ragsuite-test init --from-images  (pull-only)  OR  ragsuite-test init  (git source)',
   );
   err.code = 'DIST_NOT_READY';
   throw err;
@@ -23,17 +25,17 @@ function resolveComposeBundle() {
 
 function installHint() {
   return [
-    'Simple deploy:',
-    '  npm install -g @nitsan-ai/ragsuite-test',
-    '  ragsuite-test init',
-    '  ragsuite-test start --repo-root ~/ragsuite-test --detach',
-    'Docker is optional — init picks native automatically if Docker is not running.',
+    'Day-to-day:',
+    '  ragsuite-test start',
+    '  ragsuite-test update',
+    '  ragsuite-test stop',
   ].join('\n');
 }
 
 module.exports = {
   MODE_LOCAL,
   MODE_GIT,
+  MODE_IMAGES,
   MODE_REGISTRY,
   mode: MODE_GIT,
   assertSupportedInstall,

package/src/utils/git-install.js

@@ -1,18 +1,17 @@
 'use strict';
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const { looksLikeFullBundleRoot, looksLikeRepoRoot } = require('./paths');
+const {
+  defaultInstallDir,
+  looksLikeFullBundleRoot,
+  looksLikeRepoRoot,
+} = require('./paths');
 
 /** Default public monorepo (when the GitHub repo is public). */
 const DEFAULT_GIT_URL = 'https://github.com/nitsan-ai/RAGSUITE.git';
 
-function defaultInstallDir() {
-  return path.join(os.homedir(), 'ragsuite-test');
-}
-
 function requireGit() {
   const which = spawnSync('which', ['git'], { encoding: 'utf8' });
   if (which.status !== 0) {
@@ -49,7 +48,13 @@ function cloneGitToInstallDir(gitUrl, options = {}) {
   if (!isDirEmptyOrMissing(target)) {
     if (!force) {
       const err = new Error(
-        `Install directory is not empty: ${target}. Pass --force to remove and re-clone, or choose another --install-dir.`,
+        [
+          `Install directory is not empty: ${target}`,
+          '  If already installed:  ragsuite-test start',
+          '  To upgrade in place:   ragsuite-test update',
+          '  To wipe & reinstall:   ragsuite-test init --force',
+          '  Or use another path:   ragsuite-test init --install-dir <path>',
+        ].join('\n'),
       );
       err.code = 'INSTALL_DIR_NONEMPTY';
       throw err;

package/src/utils/global-config.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+/** User-level CLI state (not inside the app install). Like other npm CLIs. */
+function globalConfigDir() {
+  return path.join(os.homedir(), '.ragsuite-test');
+}
+
+function globalConfigPath() {
+  return path.join(globalConfigDir(), 'config.json');
+}
+
+function readGlobalConfig() {
+  const file = globalConfigPath();
+  if (!fs.existsSync(file)) return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!raw || typeof raw !== 'object') return null;
+    return {
+      installDir: raw.installDir ? path.resolve(String(raw.installDir)) : null,
+      updatedAt: raw.updatedAt || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function writeGlobalConfig(partial = {}) {
+  const dir = globalConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const existing = readGlobalConfig() || {};
+  const next = {
+    ...existing,
+    ...partial,
+    updatedAt: new Date().toISOString(),
+  };
+  if (next.installDir) next.installDir = path.resolve(String(next.installDir));
+  fs.writeFileSync(globalConfigPath(), `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  return next;
+}
+
+function setActiveInstall(installDir) {
+  return writeGlobalConfig({ installDir: path.resolve(installDir) });
+}
+
+function getActiveInstall() {
+  const g = readGlobalConfig();
+  return g && g.installDir ? g.installDir : null;
+}
+
+module.exports = {
+  globalConfigDir,
+  globalConfigPath,
+  readGlobalConfig,
+  writeGlobalConfig,
+  setActiveInstall,
+  getActiveInstall,
+};

package/src/utils/images-install.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { defaultInstallDir } = require('./git-install');
+
+function templatesRoot() {
+  return path.join(__dirname, '..', '..', 'templates', 'images');
+}
+
+function isDirEmptyOrMissing(dir) {
+  if (!fs.existsSync(dir)) return true;
+  const items = fs.readdirSync(dir).filter((n) => n !== '.DS_Store');
+  return items.length === 0;
+}
+
+function copyFile(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+/**
+ * Materialize a pull-only install dir (compose + scripts + .env.example).
+ * No monorepo source.
+ */
+function materializeImagesInstall(options = {}) {
+  const { installDir = defaultInstallDir(), force = false } = options;
+  const srcRoot = templatesRoot();
+  if (!fs.existsSync(path.join(srcRoot, 'docker-compose.yml'))) {
+    const err = new Error(
+      `Images templates missing in CLI package (${srcRoot}). Reinstall @nitsan-ai/ragsuite-test.`,
+    );
+    err.code = 'IMAGES_TEMPLATE_MISSING';
+    throw err;
+  }
+
+  const target = path.resolve(installDir);
+  if (!isDirEmptyOrMissing(target)) {
+    if (!force) {
+      const err = new Error(
+        [
+          `Install directory is not empty: ${target}`,
+          '  If already installed:  ragsuite-test start',
+          '  To upgrade in place:   ragsuite-test update',
+          '  To wipe & reinstall:   ragsuite-test init --from-images --force',
+          '  Or use another path:   ragsuite-test init --from-images --install-dir <path>',
+        ].join('\n'),
+      );
+      err.code = 'INSTALL_DIR_NONEMPTY';
+      throw err;
+    }
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+
+  fs.mkdirSync(target, { recursive: true });
+  copyFile(
+    path.join(srcRoot, 'docker-compose.yml'),
+    path.join(target, 'docker-compose.yml'),
+  );
+  copyFile(
+    path.join(srcRoot, '.env.example'),
+    path.join(target, '.env.example'),
+  );
+  copyFile(
+    path.join(srcRoot, 'scripts', 'docker-start-images.sh'),
+    path.join(target, 'scripts', 'docker-start-images.sh'),
+  );
+  copyFile(
+    path.join(srcRoot, 'scripts', 'docker-stop-images.sh'),
+    path.join(target, 'scripts', 'docker-stop-images.sh'),
+  );
+  copyFile(
+    path.join(srcRoot, 'scripts', 'docker-doctor-images.sh'),
+    path.join(target, 'scripts', 'docker-doctor-images.sh'),
+  );
+  try {
+    fs.chmodSync(path.join(target, 'scripts', 'docker-start-images.sh'), 0o755);
+    fs.chmodSync(path.join(target, 'scripts', 'docker-stop-images.sh'), 0o755);
+    fs.chmodSync(path.join(target, 'scripts', 'docker-doctor-images.sh'), 0o755);
+  } catch {
+    /* windows */
+  }
+
+  // Minimal package.json so tooling can identify the install dir
+  fs.writeFileSync(
+    path.join(target, 'package.json'),
+    `${JSON.stringify(
+      {
+        name: 'ragsuite-images-install',
+        private: true,
+        description: 'RAGSuite pull-only images install (no source tree)',
+      },
+      null,
+      2,
+    )}\n`,
+    'utf8',
+  );
+
+  return { repoRoot: target };
+}
+
+module.exports = {
+  templatesRoot,
+  materializeImagesInstall,
+  defaultInstallDir,
+};