@nitsan-ai/ragsuite-test 0.1.1 → 0.1.3

package/README.md

@@ -1,102 +1,100 @@
 # RAGSuite test CLI (`ragsuite-test`)
 
-> **TESTING PACKAGE** — `@nitsan-ai/ragsuite-test` / `ragsuite-test` is temporary.
-> **Not** the final production `@nitsan-ai/ragsuite` / `ragsuite` CLI (later release).
+> **TESTING PACKAGE** — temporary name before the final `ragsuite` CLI.
 
-Wraps monorepo Docker/native scripts. Does **not** reimplement compose.
+Two ways to run. Pick one:
 
-Requires **Node.js 18+**. **Docker is optional.** Public deploy path: **`npm` → `init --from-git`**.
+| | **A) Git source** | **B) Docker images only** |
+|--|-------------------|---------------------------|
+| Command | `ragsuite-test init` | `ragsuite-test init --from-images` |
+| On disk | Full monorepo clone | Tiny compose bundle only |
+| App code visible? | Yes | **No** (runs in containers) |
+| Needs | git + Node; Docker *or* native Postgres/Redis | Node + **Docker** |
+| Best for | Dev, debugging, native mode, reading code | Testers / “just run the app” |
+| Pros | Native mode; full scripts; offline rebuild from source | No source leak; faster to start; smaller disk |
+| Cons | Source on disk; larger checkout | Needs published GHCR images; Docker required; no native mode |
 
-## Prerequisites
+---
 
-| Need | Why | How to get it |
-|------|-----|----------------|
-| Node.js 18+ | CLI + native frontend tooling | https://nodejs.org · `brew install node` · `sudo apt install nodejs` |
-| git | `--from-git` clone | `xcode-select --install` · `brew install git` · `sudo apt install git` |
-| **SMTP** | No prompts. Real values only in **local `.env`** (gitignored) | Gmail App Password → edit `.env` |
-| LLM API key | Default in `.env.example` / `.env` — no prompt | Override in `.env` or `--llm-api-key` |
-| **Either Docker** *or* **native data stores** | Run the stack | See modes below |
+## A) Git source (clone)
 
-### Mode A — Docker (optional)
+```bash
+npm install -g @nitsan-ai/ragsuite-test
+ragsuite-test init
+# clones https://github.com/nitsan-ai/RAGSUITE.git → ~/ragsuite-test
+# auto: docker if daemon up, else native
 
-- Docker Desktop / daemon + `docker compose`
-- https://www.docker.com/products/docker-desktop/
+ragsuite-test start --repo-root ~/ragsuite-test --detach   # docker
+# or after init --mode native:
+# ragsuite-test start --repo-root ~/ragsuite-test
 
-### Mode B — Native (no Docker)
+# API http://localhost:9090
+# Web http://localhost:9091 (docker) or :9191 (native)
+ragsuite-test stop --repo-root ~/ragsuite-test
+```
 
-- `python3`, `yarn` (or corepack)
-- Postgres on **localhost:5436**, database `ragsuite_v3`
-- Redis on **localhost:6382**
+### Native (no Docker) — git install only
 
-## Install (public)
+Needs Postgres `:5436` (`ragsuite_v3`) and Redis `:6382`:
 
 ```bash
-npm install -g @nitsan-ai/ragsuite-test
+ragsuite-test init --mode native
+ragsuite-test start --repo-root ~/ragsuite-test
+```
 
-ragsuite-test init --yes \
-  --from-git \
-  --install-dir ~/ragsuite-test \
-  --mode docker
+---
 
-ragsuite-test start --repo-root ~/ragsuite-test --detach
-# API http://localhost:9090  ·  Web http://localhost:9091
-```
+## B) Docker images (no source on disk)
 
-SMTP + LLM: **no init prompts**. JWT is auto-generated. Real SMTP belongs only in local `.env` (never commit). If `.env.example` still has placeholders, init writes smoke SMTP so the app can start — edit `.env` for real mail.
+**Maintainer (once):** publish images — Actions → **Publish images (GHCR)**  
+(packages: `ghcr.io/nitsan-ai/ragsuite-backend`, `…/ragsuite-frontend`)
 
-No Docker:
+**User:**
 
 ```bash
-ragsuite-test init --yes --from-git --install-dir ~/ragsuite-test --mode native
-ragsuite-test start --repo-root ~/ragsuite-test
-# API :9090 · Expo web :9191
+npm install -g @nitsan-ai/ragsuite-test
+ragsuite-test init --from-images
+ragsuite-test start --repo-root ~/ragsuite-test --detach
+# pulls images — does NOT clone app source
+ragsuite-test stop --repo-root ~/ragsuite-test
 ```
 
-Existing checkout:
+Optional pin:
 
 ```bash
-ragsuite-test init --yes --repo-root /path/to/RAGSUITE --mode native
+# in ~/ragsuite-test/.env
+IMAGE_TAG=1.0.0
+IMAGE_REGISTRY=ghcr.io/nitsan-ai
 ```
 
-Interactive: `ragsuite-test init`
+If images are private on GHCR, make packages public or `docker login ghcr.io`.
+
+---
+
+## Prerequisites
+
+| Need | Git install | Images install |
+|------|-------------|----------------|
+| Node 18+ | Yes | Yes |
+| git | Yes | No |
+| Docker | Optional | **Required** |
+| Postgres/Redis on host | Only for `--mode native` | No (in compose) |
+
+SMTP/LLM: no init prompts. Real SMTP only in local `.env` (gitignored).
 
 ## Ports
 
 | Service | Port |
 |---------|------|
 | API | 9090 |
-| Web (Docker) | 9091 |
+| Web (Docker/images) | 9091 |
 | Web (native Expo) | 9191 |
 | Postgres | 5436 |
 | Redis | 6382 |
 
-```bash
-ragsuite-test stop --repo-root ~/ragsuite-test
-lsof -nP -iTCP:9090 -sTCP:LISTEN
-docker ps
-```
-
-## Commands
-
-| Command | Behavior |
-|---------|----------|
-| `init` | git clone or checkout → `.env` + config |
-| `start` / `stop` | `scripts/docker-*.sh` or `native-*.sh` |
-| `doctor` | prereqs + `scripts/doctor.sh` |
-| `logs` / `update` / `version` | As before |
-
-## Publish
-
-See [PUBLISH.md](./PUBLISH.md) and [TEST_DISTRIBUTION.md](./TEST_DISTRIBUTION.md).
-
-```bash
-cd cli && npm run prepublish:check
-RAGSUITE_TEST_ALLOW_PUBLISH=1 npm publish --access public   # only when approved
-```
-
-## Windows
+## Publish CLI
 
-Use WSL or Git Bash.
+See [PUBLISH.md](./PUBLISH.md). Version bump then Actions → **CLI publish**.
 
 ## Tests
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@nitsan-ai/ragsuite-test",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
-  "description": "RAGSuite testing CLI (ragsuite-test) — install from ZIP or --repo-root checkout. Temporary npm identity before public ragsuite release.",
+  "description": "RAGSuite testing CLI — init (git source) or init --from-images (pull-only, no source).",
   "main": "src/index.js",
   "bin": {
     "ragsuite-test": "./bin/ragsuite-test.js"
@@ -10,6 +10,7 @@
   "files": [
     "bin/",
     "src/",
+    "templates/",
     "package.json",
     "README.md",
     "LICENSE"

package/src/commands/doctor.js

@@ -2,22 +2,22 @@
 
 const path = require('path');
 const { resolveMode } = require('../utils/config');
-const { resolveRepoRoot } = require('../utils/paths');
+const { resolveRepoRoot, isImagesInstall } = require('../utils/paths');
 const { runScript } = require('../utils/spawn');
 
 const name = 'doctor';
-const summary = 'Run scripts/doctor.sh prerequisite checks';
+const summary = 'Run doctor checks (git or images install)';
 
 function help() {
   return `Usage: ragsuite-test doctor [options]
 
-Runs scripts/doctor.sh. Mode selects which checklist gates the exit code
-(RAGSUITE_MODE / config / --mode). Both mode sections are still printed.
+Git install: scripts/doctor.sh
+Images install: scripts/docker-doctor-images.sh
 
 Options:
-  --mode <docker|native>   Gate exit on this mode (default: docker)
-  --repo-root <path>       Monorepo root
-  --dry-run                Print the script path and exit 0
+  --mode <docker|native>   Git install gate
+  --repo-root <path>
+  --dry-run
 `;
 }
 
@@ -26,12 +26,16 @@ function run(ctx) {
     cwd: ctx.cwd,
     repoRootFlag: ctx.globals.repoRoot,
   });
-  const mode = resolveMode({
-    flagMode: ctx.globals.mode,
-    repoRoot,
-    env: ctx.env,
-  });
-  return runScript(repoRoot, path.join('scripts', 'doctor.sh'), [], {
+  const images = isImagesInstall(repoRoot);
+  const mode = images
+    ? 'docker'
+    : resolveMode({
+        flagMode: ctx.globals.mode,
+        repoRoot,
+        env: ctx.env,
+      });
+  const script = images ? 'docker-doctor-images.sh' : 'doctor.sh';
+  return runScript(repoRoot, path.join('scripts', script), [], {
     dryRun: ctx.globals.dryRun,
     env: { ...ctx.env, RAGSUITE_MODE: mode },
   });

package/src/commands/init.js

@@ -2,56 +2,55 @@
 
 const path = require('path');
 const { writeConfig, CONFIG_DIR } = require('../utils/config');
-const { ensureRagsuiteDir, resolveRepoRoot, looksLikeRepoRoot } = require('../utils/paths');
+const {
+  ensureRagsuiteDir,
+  resolveRepoRoot,
+  isImagesInstall,
+} = require('../utils/paths');
 const { assertSupportedInstall, installHint } = require('../utils/distribution');
 const {
   DEFAULT_GIT_URL,
   defaultInstallDir,
   cloneGitToInstallDir,
 } = require('../utils/git-install');
+const { materializeImagesInstall } = require('../utils/images-install');
 const { detectOs } = require('../utils/os-detect');
 const {
   printPrereqs,
   resolvePreferredMode,
-  dockerDaemonRunning,
-  commandExists,
 } = require('../utils/prereqs');
-const { ask, choose } = require('../utils/prompt');
 const {
   generateJwtSecret,
   isPlaceholderSecret,
   writeInstallEnv,
 } = require('../utils/env-file');
 const { assertPortsFree } = require('../utils/port');
-const { info, warn, error } = require('../utils/log');
+const { info, error } = require('../utils/log');
 
 const name = 'init';
-const summary = 'Installer wizard: git clone or checkout → .env + config';
+const summary = 'Install: git clone (source) or pull-only Docker images';
 
-function printSuccess(repoRoot, mode) {
+function printSuccess(repoRoot, mode, source) {
   info('');
   info('=== Install complete ===');
   info(`  Install dir : ${repoRoot}`);
+  info(`  Source      : ${source}`);
   info(`  Mode        : ${mode}`);
   info(`  Config      : ${path.join(repoRoot, CONFIG_DIR, 'config.json')}`);
   info('');
   info('  API  http://localhost:9090');
-  if (mode === 'native') {
+  if (source === 'images') {
+    info('  Web  http://localhost:9091  (images / Docker nginx)');
+  } else if (mode === 'native') {
     info('  Web  http://localhost:9191  (Expo web — native mode)');
   } else {
     info('  Web  http://localhost:9091  (Docker nginx)');
   }
   info('');
-  info('  Docker is optional: native mode needs host Postgres :5436 + Redis :6382.');
-  info('  Each install directory is one deployment / one organization.');
-  info('');
   info('Next steps:');
-  info(`  1. ragsuite-test start --repo-root ${repoRoot}${mode === 'docker' ? ' --detach' : ''}`);
-  if (mode === 'native') {
-    info('  2. Open http://localhost:9191 and bootstrap the first admin');
-  } else {
-    info('  2. Open http://localhost:9091 and bootstrap the first admin');
-  }
+  const detach = mode === 'docker' || source === 'images' ? ' --detach' : '';
+  info(`  1. ragsuite-test start --repo-root ${repoRoot}${detach}`);
+  info('  2. Open the Web URL above and bootstrap the first admin');
   info(`  3. ragsuite-test doctor --repo-root ${repoRoot}`);
   info('');
   info(installHint());
@@ -60,29 +59,27 @@ function printSuccess(repoRoot, mode) {
 function help() {
   return `Usage: ragsuite-test init [options]
 
-Interactive installer (or --yes for CI) that:
-  - detects OS / prerequisites (Docker is optional)
-  - clones the public monorepo or configures an existing checkout
-  - writes .ragsuite-test/config.json and .env
-  - JWT is auto-generated; SMTP + LLM defaults come from .env.example
-  - checks ports 9090, 9091, 5436, 6382
-
-Install sources (pick one):
-  --from-git [url]         Clone public monorepo (default: ${DEFAULT_GIT_URL})
-  --repo-root <path>       Use an existing monorepo checkout
+Two install styles:
 
-Run mode (Docker is NOT required):
-  --mode native            Default when Docker is unavailable — host Postgres/Redis
-  --mode docker            Full compose stack (needs Docker Desktop / daemon)
+  A) Source on disk (git) — default
+       ragsuite-test init
+       Clones ${DEFAULT_GIT_URL} → ~/ragsuite-test
+       Supports --mode docker|native
 
-Optional overrides (defaults come from .env.example — usually not needed):
-  --llm-api-key <key>      Override CUSTOM_LLM_INTERNAL_API_KEY
-  --smtp-host / --smtp-user / --smtp-password / --email-from
+  B) No source (Docker images only)
+       ragsuite-test init --from-images
+       Copies a tiny compose bundle → ~/ragsuite-test
+       Pulls ghcr.io/nitsan-ai/ragsuite-backend|frontend (no git clone of app code)
 
 Options:
-  --install-dir <path>     Target for --from-git (default: ~/ragsuite-test)
+  --from-images            Pull-only images install (no monorepo source)
+  --from-git [url]         Clone this URL (default public repo)
+  --repo-root <path>       Configure an existing git checkout
+  --install-dir <path>     Target dir (default: ~/ragsuite-test)
+  --mode <docker|native>   Git install only (images install is always docker)
   --force                  Overwrite non-empty install dir / existing .env
-  --yes, -y                Non-interactive (requires --from-git or --repo-root)
+  --yes, -y                Non-interactive
+  --llm-api-key / --smtp-* Optional overrides
 `;
 }
 
@@ -100,12 +97,13 @@ function resolveLlmOverride(g, env) {
   if (env.RAGSUITE_TEST_LLM_API_KEY && !isPlaceholderSecret(env.RAGSUITE_TEST_LLM_API_KEY)) {
     return env.RAGSUITE_TEST_LLM_API_KEY;
   }
-  return null; // keep .env.example default
+  return null;
 }
 
-function countSources(fromGit, repoRootFlag) {
+function countSources(fromGit, fromImages, repoRootFlag) {
   let n = 0;
   if (fromGit !== null && fromGit !== undefined) n += 1;
+  if (fromImages) n += 1;
   if (repoRootFlag) n += 1;
   return n;
 }
@@ -113,15 +111,14 @@ function countSources(fromGit, repoRootFlag) {
 async function run(ctx) {
   assertSupportedInstall();
   const g = ctx.globals;
-  const interactive = Boolean(process.stdin.isTTY) && !g.yes;
 
   if (g.fromRelease) {
-    error('--from-release is not supported. Use --from-git or --repo-root.');
+    error('--from-release is not supported. Use init, --from-images, --from-git, or --repo-root.');
     return 1;
   }
 
-  if (countSources(g.fromGit, g.repoRoot) > 1) {
-    error('Use only one of --from-git or --repo-root');
+  if (countSources(g.fromGit, g.fromImages, g.repoRoot) > 1) {
+    error('Use only one of --from-images, --from-git, or --repo-root');
     return 1;
   }
 
@@ -129,81 +126,30 @@ async function run(ctx) {
   info(`OS: ${osInfo.label} (${osInfo.platform})`);
 
   let fromGit = g.fromGit;
+  let fromImages = Boolean(g.fromImages);
   let repoRootFlag = g.repoRoot;
-  let installDir = g.installDir || defaultInstallDir();
-  let mode = g.mode || null;
+  const installDir = g.installDir || defaultInstallDir();
 
-  if (g.yes) {
-    if (fromGit === null && !repoRootFlag) {
-      error('--yes requires --from-git [url] or --repo-root <path>');
-      return 1;
-    }
-  } else if (interactive && fromGit === null && !repoRootFlag) {
-    const method = await choose(
-      'Install method:',
-      [
-        {
-          id: 'git',
-          label: 'Public git clone (--from-git) — recommended',
-        },
-        {
-          id: 'checkout',
-          label: 'Existing checkout (--repo-root)',
-        },
-      ],
-      { defaultIndex: 0 },
-    );
-    if (method.id === 'git') {
-      const url = await ask('Git repository URL', {
-        defaultValue: DEFAULT_GIT_URL,
-        yesMode: false,
-      });
-      fromGit = url || DEFAULT_GIT_URL;
-      installDir = await ask('Install directory', {
-        defaultValue: defaultInstallDir(),
-        yesMode: false,
-      });
-    } else {
-      repoRootFlag = await ask('Path to existing RAGSUITE checkout', { yesMode: false });
-      if (!repoRootFlag || !looksLikeRepoRoot(path.resolve(repoRootFlag))) {
-        error('Not a valid checkout (need scripts/docker-start.sh)');
-        return 1;
-      }
-    }
+  if (!fromImages && fromGit === null && !repoRootFlag) {
+    fromGit = '';
+    info(`Install style: git clone (source on disk)`);
+    info(`  ${DEFAULT_GIT_URL} → ${path.resolve(installDir)}`);
+  }
 
-    const dockerOk = commandExists('docker') && dockerDaemonRunning();
-    const modeChoice = await choose(
-      'Run mode (Docker is optional — native works without Docker):',
-      [
-        {
-          id: 'native',
-          label: 'Native — no Docker; needs Postgres :5436 + Redis :6382 on this machine',
-        },
-        {
-          id: 'docker',
-          label: dockerOk
-            ? 'Docker — full compose stack (Docker Desktop / daemon)'
-            : 'Docker — not available on this machine (install Docker Desktop first)',
-        },
-      ],
-      { defaultIndex: 0 },
-    );
-    mode = modeChoice.id;
-    if (mode === 'docker' && !dockerOk) {
-      warn('Docker is not available — switching to native mode.');
-      mode = 'native';
-    }
-  } else if (fromGit === null && !repoRootFlag) {
-    error('Pass --from-git / --repo-root, or run in a TTY for the interactive wizard');
-    return 1;
+  if (fromImages) {
+    info('Install style: Docker images only (no app source on disk)');
+    info(`  Target: ${path.resolve(installDir)}`);
   }
 
-  if (!mode) {
-    mode = resolvePreferredMode(g.mode);
-    info(`Run mode: ${mode} (Docker is optional; pass --mode docker|native to force)`);
+  let mode;
+  if (fromImages) {
+    mode = 'docker';
+  } else {
+    mode = g.mode || resolvePreferredMode(null);
   }
+  info(`Run mode: ${mode}`);
 
-  const needGit = fromGit !== null && fromGit !== undefined;
+  const needGit = !fromImages && fromGit !== null && fromGit !== undefined;
   if (!printPrereqs(mode, { needGit })) {
     error('Fix prerequisites above and re-run init');
     return 1;
@@ -211,7 +157,7 @@ async function run(ctx) {
 
   const jwtSecret = generateJwtSecret();
   info(`JWT_SECRET_KEY will be auto-generated (…${jwtSecret.slice(-8)})`);
-  info('SMTP + LLM: using defaults from .env.example (optional flags can override).');
+  info('SMTP + LLM: from .env.example into .env (no prompts).');
 
   const llmKey = resolveLlmOverride(g, ctx.env);
   const smtp = optionalSmtpOverrides(g, ctx.env);
@@ -229,7 +175,15 @@ async function run(ctx) {
   let source = 'checkout';
 
   try {
-    if (fromGit !== null && fromGit !== undefined) {
+    if (fromImages) {
+      const result = materializeImagesInstall({
+        installDir,
+        force: g.force,
+      });
+      repoRoot = result.repoRoot;
+      source = 'images';
+      info(`Images bundle installed at ${repoRoot}`);
+    } else if (fromGit !== null && fromGit !== undefined) {
       const url = fromGit === '' ? DEFAULT_GIT_URL : fromGit;
       info(`Cloning ${url} → ${path.resolve(installDir)}`);
       const result = cloneGitToInstallDir(url, {
@@ -245,6 +199,7 @@ async function run(ctx) {
         repoRootFlag,
         env: ctx.env,
       });
+      if (isImagesInstall(repoRoot)) source = 'images';
     }
   } catch (err) {
     error(err.message || String(err));
@@ -277,7 +232,7 @@ async function run(ctx) {
 
   info(`Wrote ${path.join(repoRoot, CONFIG_DIR, 'config.json')}`);
   info(`  mode=${cfg.mode} source=${cfg.source}`);
-  printSuccess(repoRoot, mode);
+  printSuccess(repoRoot, mode, source);
   return 0;
 }
 

package/src/commands/start.js

@@ -2,25 +2,25 @@
 
 const path = require('path');
 const { resolveMode } = require('../utils/config');
-const { resolveRepoRoot } = require('../utils/paths');
+const { resolveRepoRoot, isImagesInstall } = require('../utils/paths');
 const { runScript } = require('../utils/spawn');
 const { assertApiPortFree } = require('../utils/port');
 const { error } = require('../utils/log');
 
 const name = 'start';
-const summary = 'Start stack via docker-start.sh or native-start.sh';
+const summary = 'Start stack (git scripts or images pull-only)';
 
 function help() {
-  return `Usage: ragsuite-test start [options] [-- script-args...]
+  return `Usage: ragsuite-test start [options]
 
-Calls scripts/docker-start.sh (mode=docker) or scripts/native-start.sh (mode=native).
-Does not reimplement compose logic. Extra args after -- are forwarded (e.g. --detach).
+Git install: scripts/docker-start.sh or native-start.sh
+Images install (--from-images): scripts/docker-start-images.sh (pull, no build)
 
 Options:
-  --mode <docker|native>   Override config / RAGSUITE_MODE
-  --repo-root <path>       Monorepo root
-  --dry-run                Print the script path and exit 0
-  --detach, -d             Forwarded to docker-start.sh (also accepted without --)
+  --mode <docker|native>   Override (git install; images always docker)
+  --repo-root <path>       Install root
+  --dry-run                Print script path and exit 0
+  --detach, -d             Detached start
 `;
 }
 
@@ -29,14 +29,22 @@ async function run(ctx) {
     cwd: ctx.cwd,
     repoRootFlag: ctx.globals.repoRoot,
   });
-  const mode = resolveMode({
-    flagMode: ctx.globals.mode,
-    repoRoot,
-    env: ctx.env,
-  });
+  const images = isImagesInstall(repoRoot);
+  const mode = images
+    ? 'docker'
+    : resolveMode({
+        flagMode: ctx.globals.mode,
+        repoRoot,
+        env: ctx.env,
+      });
+
+  let scriptName;
+  if (images) {
+    scriptName = 'docker-start-images.sh';
+  } else {
+    scriptName = mode === 'native' ? 'native-start.sh' : 'docker-start.sh';
+  }
 
-  const scriptName = mode === 'native' ? 'native-start.sh' : 'docker-start.sh';
-  const rel = path.join('scripts', scriptName);
   const forward = normalizeStartArgs(ctx.commandArgs);
 
   if (!ctx.globals.dryRun) {
@@ -48,7 +56,7 @@ async function run(ctx) {
     }
   }
 
-  return runScript(repoRoot, rel, forward, {
+  return runScript(repoRoot, path.join('scripts', scriptName), forward, {
     dryRun: ctx.globals.dryRun,
     env: { ...ctx.env, RAGSUITE_MODE: mode },
   });

package/src/commands/stop.js

@@ -2,22 +2,23 @@
 
 const path = require('path');
 const { resolveMode } = require('../utils/config');
-const { resolveRepoRoot } = require('../utils/paths');
+const { resolveRepoRoot, isImagesInstall } = require('../utils/paths');
 const { runScript } = require('../utils/spawn');
 
 const name = 'stop';
-const summary = 'Stop stack via docker-stop.sh or native-stop.sh';
+const summary = 'Stop stack (git scripts or images pull-only)';
 
 function help() {
   return `Usage: ragsuite-test stop [options]
 
-Calls scripts/docker-stop.sh or scripts/native-stop.sh based on mode.
-Never wipes Docker volumes (same as docker-stop.sh).
+Git install: docker-stop.sh / native-stop.sh
+Images install: docker-stop-images.sh
+Never wipes Docker volumes.
 
 Options:
-  --mode <docker|native>   Override config / RAGSUITE_MODE
-  --repo-root <path>       Monorepo root
-  --dry-run                Print the script path and exit 0
+  --mode <docker|native>   Override (git install)
+  --repo-root <path>       Install root
+  --dry-run                Print script path and exit 0
 `;
 }
 
@@ -26,12 +27,21 @@ function run(ctx) {
     cwd: ctx.cwd,
     repoRootFlag: ctx.globals.repoRoot,
   });
-  const mode = resolveMode({
-    flagMode: ctx.globals.mode,
-    repoRoot,
-    env: ctx.env,
-  });
-  const scriptName = mode === 'native' ? 'native-stop.sh' : 'docker-stop.sh';
+  const images = isImagesInstall(repoRoot);
+  const mode = images
+    ? 'docker'
+    : resolveMode({
+        flagMode: ctx.globals.mode,
+        repoRoot,
+        env: ctx.env,
+      });
+
+  const scriptName = images
+    ? 'docker-stop-images.sh'
+    : mode === 'native'
+      ? 'native-stop.sh'
+      : 'docker-stop.sh';
+
   return runScript(repoRoot, path.join('scripts', scriptName), [], {
     dryRun: ctx.globals.dryRun,
     env: { ...ctx.env, RAGSUITE_MODE: mode },