jarvis-launcher 1.2.0-alpha.6 → 1.2.0

package/README.md

@@ -116,7 +116,7 @@ Notes:
 
 ### Pre-seeding the initial state (`seed/state.json`)
 
-An integrator packaging a scenario can ship a **`seed/state.json`** file to give the seed an identity (a name and description) and pre-declare the environment's **initial** state, so the first `init`/`start` picks up the right project name, optional profiles, and image tag without anyone having to remember the flags. It is read **only when the scenario has no `.orchestrator/state.json` yet** (a brand-new environment); once the scenario has been started, its own `.orchestrator/state.json` drives everything and the seed is ignored.
+An integrator packaging a scenario can ship a **`seed/state.json`** file to give the seed an identity (a name and description) and pre-declare the environment's **initial** state, so the first `init`/`start` picks up the right project name, optional profiles, and Jarvis version (image tag) without anyone having to remember the flags. It is read **only when the scenario has no `.orchestrator/state.json` yet** (a brand-new environment); once the scenario has been started, its own `.orchestrator/state.json` drives everything and the seed is ignored.
 
 Only the properties below are honored — anything else in the file (notably a `ports` block) is ignored, so you can copy a working environment's `.orchestrator/state.json` verbatim and only the portable bits are applied (fresh host ports are always re-allocated for the new machine):
 
@@ -136,19 +136,19 @@ Only the properties below are honored — anything else in the file (notably a `
 | `description` | free-text summary of what the seed installs (identity metadata; not applied to the environment) | none |
 | `projectName` | the `docker compose -p` project name | derived from the folder name |
 | `enabledProfiles` | optional profiles to turn on (`sql`, `mail`) | none |
-| `tag` | base image tag to pin the scenario to | `latest` |
+| `tag` | Jarvis version (base image tag) to pin the scenario to | `latest` |
 
 `name` and `description` describe the seed itself — they are read back via `readSeedState` (the groundwork for letting the launcher list and choose a seed to import) but do not change what `start` brings up.
 
 Explicit CLI flags always win over the seed: `--tag` overrides `tag`, and `--sql`/`--mail` are **added to** the seed's `enabledProfiles`.
 
-In the interactive homepage, choosing **Start** on a brand-new (uninitialized) folder first asks for the **scenario folder** (default: the current directory — one Enter keeps it, like Stop/Restore/Backup), then opens a submenu for that folder. A **local `seed/` takes precedence** over the remote catalog — when the folder already ships one (any payload counts, including a config-only seed), the remote catalog is never contacted (no client-secret prompt / network):
+The interactive homepage always operates on the **current working directory** — it never asks for a folder (use the CLI's positional `[folder]` to target elsewhere). Choosing **Start** on a brand-new (uninitialized) directory opens a submenu for it, and every branch creates a **new environment**, so each one first asks for the **environment name** (pre-filled with the name that would be derived anyway — the seed-declared one when present, else the folder name — so one Enter keeps it). A **local `seed/` takes precedence** over the remote catalog — when the directory already ships one (any payload counts, including a config-only seed), the remote catalog is never contacted (no client-secret prompt / network):
 
-- **Start from local seed** *(shown only when a local `seed/` is present)* — install the shipped seed by starting the folder. A seed **declared** by `seed/state.json` dictates its own environment and starts as-is (the status header above already previews what it will install); an **undeclared** seed (data/config only) still asks for the image tag and the optional SQL/mail toggles — with SQL defaulting to **on** when the seed ships a SQL backup.
-- **Start from an existing scenario** *(shown only when there is no local seed)* — pick from the **remote seed catalog**: the `.zip` blobs in the `seedintegratori`/`seeds` container, each shown by its blob-metadata `name`/`description`. Picking one downloads and extracts it into `<folder>/seed` (staged first — a failed download never leaves a half-installed or wiped seed), then starts it. An empty or unreachable catalog (offline / rejected secret) shows a short notice and returns.
-- **Start from an empty environment** — bring up a blank stack. If the folder ships a `seed/` (even a config-only one), this first asks to confirm and then **permanently deletes** the `seed/` folder (so the stack comes up empty instead of re-applying the seed), then asks for the image tag and the optional SQL/mail toggles.
+- **Start from local seed** *(shown only when a local `seed/` is present)* — install the shipped seed by starting the directory. A seed **declared** by `seed/state.json` dictates the rest of its environment and starts right after the name prompt (the status header above already previews what it will install); an **undeclared** seed (data/config only) still asks for the Jarvis version and the optional SQL/mail toggles — with SQL defaulting to **on** when the seed ships a SQL backup.
+- **Start from an existing scenario** *(shown only when there is no local seed)* — pick from the **remote seed catalog**: the `.zip` blobs in the `seedintegratori`/`seeds` container, each shown by its blob-metadata `name`/`description`. Picking one downloads and extracts it into the directory's `seed/` (staged first — a failed download never leaves a half-installed or wiped seed), asks for the environment name (pre-filled with the installed seed's declared name when it pins one), then starts it. An empty or unreachable catalog (offline / rejected secret) shows a short notice and returns.
+- **Start from an empty environment** — bring up a blank stack. If the directory ships a `seed/` (even a config-only one), this first asks to confirm and then **permanently deletes** the `seed/` folder (so the stack comes up empty instead of re-applying the seed), then asks for the environment name, the Jarvis version and the optional SQL/mail toggles.
 
-Choosing **Start** on an already-initialized folder (a stopped environment) skips the folder prompt and the submenu and resumes it directly.
+Choosing **Start** in an already-initialized directory (a stopped environment) skips the submenu — and the name prompt, since the environment already has its name — and resumes it directly.
 
 ### Pre-seeding the base configs (`seed/config/`)
 
@@ -189,10 +189,10 @@ After a restore, Elasticsearch repopulates in the background; the launcher print
 |---|---|---|
 | [`init`](#init) | `init [folder]` | Provision the three base config files into an empty/config-less folder. |
 | [`registry-login`](#registry-login) | `registry-login [--registry <host>] [--client-secret <secret>]` | Authenticate Docker against the image registry as the Entra application (once per machine). |
-| [`start`](#start) | `start [folder] [--sql] [--mail] [--force]` | Bring up the full stack (auto-init + auto-restore) and report the URLs. |
+| [`start`](#start) | `start [folder] [--sql] [--mail] [--force] [--tag <T>] [--name <N>]` | Bring up the full stack (auto-init + auto-restore) and report the URLs. |
 | [`stop`](#stop) | `stop [folder]` | Stop the stack (remove containers) while keeping all on-disk data. |
 | [`restore`](#restore) | `restore [folder] [--force]` | Restore the prepared artifact into the running stack (gated by `--force`). |
-| [`update`](#update) | `update [folder] --tag <T>` | Pull a new image tag and recreate the stack on it, preserving data. |
+| [`update`](#update) | `update [folder] --tag <T>` | Update the stack to another Jarvis version (pull + recreate), preserving data. |
 | [`enable`](#enable) | `enable [folder] <sql\|mail>` | Attach an optional service (SQL Server or mail catcher) to the stack. |
 | [`login`](#login) | `login [folder] [--admin\|--user]` | Open the browser at the Jarvis dev-login (impersonation) URL. |
 
@@ -217,7 +217,7 @@ Forces a fresh `docker login` against the integrator registry (as the Entra appl
 ### `start`
 
 ```bash
-jarvis-launcher start [folder] [--sql] [--mail] [--force]
+jarvis-launcher start [folder] [--sql] [--mail] [--force] [--tag <tag>] [--name <name>]
 ```
 
 Brings up the full, logged-in environment in one command. See [Quick start](#quick-start-brand-new-scenario) for the brand-new-folder flow.
@@ -227,6 +227,8 @@ Brings up the full, logged-in environment in one command. See [Quick start](#qui
 | `--sql` | Also start the optional **SQL Server** service. If a `.bak` is present under `<folder>/seed/sqlbackup`, it is restored after the SQL container is healthy. |
 | `--mail` | Also start the optional **mail catcher** (catch-all SMTP + web UI). |
 | `--force` | Run the restore **even if the database already has data** (drops the existing data first). Without it, a populated DB is left as-is. |
+| `--tag <tag>` | The Jarvis version (image tag) to bring the stack up on (defaults to `latest`, or the version the environment is already pinned to). |
+| `--name <name>` | The environment name (the compose project name) for a **brand-new** environment; defaults to the seed-declared name, else the folder name. Ignored on an existing environment — its persisted name always wins. |
 
 On success it prints the Web UI / API URL, both dev-login links, and the Mongo / ES (and optional SQL / mail) host ports. Enabled optional profiles are remembered, so a later plain `start` keeps them on.
 
@@ -260,7 +262,7 @@ The explicit `restore` never touches the three base config files at the scenario
 jarvis-launcher update [folder] --tag <tag>
 ```
 
-Moves the stack to a new image tag, **preserving all data and without restoring**. It is **pull-first** so you are never left with no runnable environment:
+Moves the stack to another Jarvis version (image tag), **preserving all data and without restoring**. It is **pull-first** so you are never left with no runnable environment:
 
 1. resolves the architecture-correct image variant (a `-arm` suffix is added automatically on ARM hosts) and **pulls it first** (re-authenticating + retrying once if needed);
 2. **only if the pull succeeds**, recreates the stack on the new image (down → up, data kept via the `/scenario` host mount and the Mongo/ES named volumes) — **no restore**, the existing data is reused;

package/dist/cli.js

@@ -1,153 +1,2 @@
 #!/usr/bin/env node
-import { realpathSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import { Command, CommanderError } from 'commander';
-import { registerInit } from './commands/init.js';
-import { registerRegistryLoginCommand } from './commands/registry-login.js';
-import { registerStartCommand } from './commands/start.js';
-import { registerStopCommand } from './commands/stop.js';
-import { registerRestoreCommand } from './commands/restore.js';
-import { registerBackupCommand } from './commands/backup.js';
-import { loginCommand } from './commands/login.js';
-import { update } from './commands/update.js';
-import { enable } from './commands/enable.js';
-import { OPTIONAL_PROFILES, isOptionalProfile } from './lib/profiles.js';
-import { runHomepage } from './homepage/home.js';
-// Read version from package.json at runtime. Using createRequire keeps this
-// compatible with NodeNext ESM without relying on a JSON import assertion
-// (which would also pull package.json into the emitted dist/ tree via rootDir).
-const require = createRequire(import.meta.url);
-const pkg = require('../package.json');
-const program = new Command();
-program
-    .name('jarvis-launcher')
-    .description('Prepare a scenario folder and run the full Jarvis all-in-one stack via docker compose.')
-    .version(pkg.version);
-// --- subcommand registration (T-2-23) ---------------------------------------
-//
-// The command modules were built in parallel and expose intentionally
-// different shapes. `cli.ts` is the single place that knows about all of them and
-// reconciles those shapes onto one program (commands never import each other):
-//
-//   * `register…Command(program)` builders register themselves and return nothing
-//     useful to us — call them for their side effect: init, registry-login, start,
-//     stop, restore, backup.
-//   * `loginCommand()` returns a ready-made `Command` instance → `addCommand`.
-//   * `update` / `enable` export only an action function (no builder), so we
-//     declare the `program.command(...)` surface here and call the action.
-registerInit(program);
-registerRegistryLoginCommand(program);
-registerStartCommand(program);
-registerStopCommand(program);
-registerRestoreCommand(program);
-registerBackupCommand(program);
-program.addCommand(loginCommand());
-// `update [folder] --tag <tag>` — the action fn lives in commands/update.ts. The
-// tag is required (the update is meaningless without a target image tag).
-program
-    .command('update')
-    .description('Pull a new image tag and recreate the stack on it, preserving all data.')
-    .argument('[folder]', 'scenario folder (defaults to the current directory)')
-    .requiredOption('--tag <tag>', 'the image tag to update to (e.g. latest, 1.2.3)')
-    .action(async (folder, opts) => {
-    await update({ folder, tag: opts.tag });
-});
-// `enable [folder] <service>` — `service` is `sql` | `mail`. The action fn lives
-// in commands/enable.ts; we validate the positional here so an unknown service
-// yields a clear message + non-zero exit (mapped by the dispatcher below).
-program
-    .command('enable')
-    .description('Attach an optional service (sql | mail) to a scenario stack.')
-    .argument('[folder]', 'scenario folder (defaults to the current directory)')
-    .argument('<service>', 'optional service to enable: sql or mail')
-    .action(async (folder, service) => {
-    if (!isOptionalProfile(service)) {
-        throw new Error(`Unknown service "${service}". Expected one of: ${OPTIONAL_PROFILES.join(', ')}.`);
-    }
-    await enable({ folder, service });
-});
-// `help [command]` — print general usage, or the usage of a single command. The
-// argument is optional; with no argument it behaves like the top-level help.
-program
-    .command('help [command]')
-    .description('Display help for the CLI or for a specific command.')
-    .action((commandName) => {
-    if (!commandName) {
-        program.outputHelp();
-        return;
-    }
-    const sub = program.commands.find((c) => c.name() === commandName);
-    if (!sub) {
-        throw new Error(`Unknown command "${commandName}". Run "jarvis-launcher help" to list commands.`);
-    }
-    sub.outputHelp();
-});
-// --- no-args TTY dispatch (FR-HOME-001/002/003, SC-HOME-001/007) -------------
-//
-// "No subcommand" = only the node binary + this script path (`argv.length <= 2`).
-// The interactive homepage may only launch when BOTH stdin and stdout are real
-// TTYs (R-HOME5): a stdout-piped-but-stdin-a-TTY invocation must NOT hang waiting
-// on a keypress, so requiring both keeps the non-interactive path on the
-// help+exit branch below. Pure and exported so the three branches are unit-tested
-// with no TTY (see cli.test.ts).
-export function shouldRunHomepage(argv, stdinIsTTY, stdoutIsTTY) {
-    return argv.length <= 2 && Boolean(stdinIsTTY && stdoutIsTTY);
-}
-export function isEntrypoint(modulePath, argv1, canonicalize = realpathSync.native) {
-    if (!argv1) {
-        return false;
-    }
-    try {
-        return canonicalize(modulePath) === canonicalize(argv1);
-    }
-    catch {
-        return modulePath === argv1;
-    }
-}
-// --- error → message + non-zero exit (FR-ORC-034/035/046) -------------------
-//
-// Every command's action is async; commander surfaces a rejected action promise
-// out of `parseAsync`. We catch here and print only the error's `.message` —
-// which the libs build to carry surfaced execa stderr verbatim — never a raw
-// stack trace or an execa object dump. A `CommanderError` (e.g. a missing
-// required option, or `--version`/`--help` exit) is commander's own controlled
-// flow: it has already printed its message and chosen an exit code, so we honor
-// that exit code instead of re-printing.
-async function main() {
-    // No subcommand + a real interactive terminal ⇒ the always-on homepage
-    // (FR-HOME-001). Done BEFORE parseAsync so commander never sees the empty argv.
-    if (shouldRunHomepage(process.argv, Boolean(process.stdin.isTTY), Boolean(process.stdout.isTTY))) {
-        await runHomepage();
-        return;
-    }
-    // No subcommand but NOT interactive (piped / CI / non-TTY) ⇒ print help to
-    // stderr and exit non-zero, EXPLICITLY (FR-HOME-002, SC-HOME-007). Handled
-    // here rather than relying on commander's default no-args behavior so the
-    // help+non-zero guarantee can't regress with a commander version bump.
-    if (process.argv.length <= 2) {
-        program.outputHelp({ error: true });
-        process.exit(1);
-    }
-    // An explicit command ⇒ the existing dispatch path, completely unchanged
-    // (FR-HOME-003, FR-HOME-027), including the CommanderError → exit-code mapping.
-    try {
-        await program.parseAsync(process.argv);
-    }
-    catch (err) {
-        if (err instanceof CommanderError) {
-            process.exit(err.exitCode);
-        }
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Error: ${message}`);
-        process.exit(1);
-    }
-}
-// Run only when executed as the program entry point (not when imported by a
-// test). Comparing this module's file path to the invoked script (argv[1]) keeps
-// `import { shouldRunHomepage }` from cli.test.ts side-effect-free, so importing
-// the module never spawns the homepage or touches process.argv/exit.
-if (isEntrypoint(fileURLToPath(import.meta.url), process.argv[1])) {
-    void main();
-}
-//# sourceMappingURL=cli.js.map
+var a=Object.defineProperty;var n=(r,e)=>a(r,"name",{value:e,configurable:!0});import{realpathSync as i}from"node:fs";import{createRequire as s}from"node:module";import{fileURLToPath as m}from"node:url";import{Command as p,CommanderError as c}from"commander";import{registerInit as l}from"./commands/init.js";import{registerRegistryLoginCommand as d}from"./commands/registry-login.js";import{registerStartCommand as f}from"./commands/start.js";import{registerStopCommand as u}from"./commands/stop.js";import{registerRestoreCommand as g}from"./commands/restore.js";import{registerBackupCommand as h}from"./commands/backup.js";import{registerDeleteCommand as v}from"./commands/delete.js";import{loginCommand as y}from"./commands/login.js";import{update as C}from"./commands/update.js";import{enable as w}from"./commands/enable.js";import{OPTIONAL_PROFILES as k,isOptionalProfile as E}from"./lib/profiles.js";import{runHomepage as x}from"./homepage/home.js";const R=s(import.meta.url),T=R("../package.json"),o=new p;o.name("jarvis-launcher").description("Prepare a scenario folder and run the full Jarvis all-in-one stack via docker compose.").version(T.version),l(o),d(o),f(o),u(o),g(o),h(o),v(o),o.addCommand(y()),o.command("update").description("Update the stack to another Jarvis version (pull + recreate), preserving all data.").argument("[folder]","scenario folder (defaults to the current directory)").requiredOption("--tag <tag>","the Jarvis version (image tag) to update to (e.g. latest, 1.2.3)").action(async(r,e)=>{await C({folder:r,tag:e.tag})}),o.command("enable").description("Attach an optional service (sql | mail) to a scenario stack.").argument("[folder]","scenario folder (defaults to the current directory)").argument("<service>","optional service to enable: sql or mail").action(async(r,e)=>{if(!E(e))throw new Error(`Unknown service "${e}". Expected one of: ${k.join(", ")}.`);await w({folder:r,service:e})}),o.command("help [command]").description("Display help for the CLI or for a specific command.").action(r=>{if(!r){o.outputHelp();return}const e=o.commands.find(t=>t.name()===r);if(!e)throw new Error(`Unknown command "${r}". Run "jarvis-launcher help" to list commands.`);e.outputHelp()});function b(r,e,t){return r.length<=2&&!!(e&&t)}n(b,"shouldRunHomepage");function q(r,e,t=i.native){if(!e)return!1;try{return t(r)===t(e)}catch{return r===e}}n(q,"isEntrypoint");async function H(){if(b(process.argv,!!process.stdin.isTTY,!!process.stdout.isTTY)){await x();return}process.argv.length<=2&&(o.outputHelp({error:!0}),process.exit(1));try{await o.parseAsync(process.argv)}catch(r){r instanceof c&&process.exit(r.exitCode);const e=r instanceof Error?r.message:String(r);console.error(`Error: ${e}`),process.exit(1)}}n(H,"main"),q(m(import.meta.url),process.argv[1])&&H();export{q as isEntrypoint,b as shouldRunHomepage};

package/dist/commands/backup.js

@@ -1,160 +1 @@
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { composeUp, composeStop, listComposeServices } from '../lib/docker.js';
-import { fetchListDatabases, isJarvisDataPresent } from '../lib/mongo.js';
-import { generateEnv, readMongoCreds, templatePath, DEFAULT_SQL_SA_PASSWORD } from '../lib/compose.js';
-import { backup } from '../lib/backup.js';
-import { findBackupFile, snapshotSql } from '../lib/sql.js';
-import { readState, defaultProjectName, envFilePath } from '../lib/state.js';
-import { resolveScenario } from '../lib/scenario.js';
-import { progress, createProgressBar } from '../lib/progress.js';
-/**
- * Run the seed-snapshot backup for a scenario folder.
- *
- * @throws when the scenario was never started (no persisted state) or its
- * database is empty (the caller maps this to a clear message + non-zero exit in
- * `cli.ts`).
- */
-export async function runBackup(options = {}) {
-    const base = resolveScenario(options.folder);
-    // Single source of Mongo creds (R-ORC2): read once, pass everywhere.
-    const creds = readMongoCreds(base);
-    // A backup needs a started stack: the compose project name is persisted by
-    // `start`. With no state (never started) there is nothing to back up — fail
-    // fast with a clear, actionable message BEFORE any composeUp, mirroring
-    // `restore`/`stop`.
-    const state = await readState(base);
-    if (state === null) {
-        throw new Error(`No started stack found for "${base}" (no .orchestrator/state.json). ` +
-            'Run `jarvis-launcher start` first, then `backup`.');
-    }
-    const project = state.projectName ?? defaultProjectName(base);
-    const network = `${project}_default`;
-    const profiles = state.enabledProfiles ?? [];
-    // When the scenario runs SQL, the snapshot must also refresh its `.bak` — so the
-    // `sql` service is brought up alongside `mongo` (both PUBLIC images) and stopped
-    // again afterwards on the same terms. With SQL off there is nothing to snapshot.
-    const sqlEnabled = profiles.includes('sql');
-    const startupServices = sqlEnabled ? ['mongo', 'sql'] : ['mongo'];
-    // Regenerate the orchestrator-owned `.env` before any compose call (the
-    // template substitutes from it) — verbatim the restore pattern.
-    const template = templatePath();
-    const envFile = envFilePath(base);
-    const env = generateEnv({ base, state, tag: 'latest', profiles });
-    writeFileSync(envFile, env);
-    // Bring mongo (and sql, when enabled) up healthy BEFORE the empty-check/dump.
-    // Both are PUBLIC images (`mongo:6.0.15`, `mcr.microsoft.com/mssql/server`) and
-    // the backup never starts `jarvis` at all, so the bring-up must NOT be
-    // auth-gated (same rationale as restore's). `sql` has no compose healthcheck, so
-    // `--wait` only confirms it is running — `snapshotSql` does its own SELECT-1
-    // wait-healthy poll before the BACKUP.
-    progress(sqlEnabled
-        ? 'Starting MongoDB and SQL Server — waiting until they are up…'
-        : 'Starting MongoDB — waiting until it is healthy…');
-    await composeUp({
-        project,
-        template,
-        envFile,
-        services: startupServices,
-        wait: true,
-        authGate: false,
-    });
-    // The reverse of restore's gate: an EMPTY database means there is nothing to
-    // back up — refuse, so an empty dump can never clobber a good seed snapshot.
-    progress('Checking that the database has data to back up…');
-    const listDatabases = await fetchListDatabases({ creds, network });
-    if (!isJarvisDataPresent(listDatabases)) {
-        throw new Error('Nothing to back up: the scenario database is empty. ' +
-            'The existing seed folder was left untouched.');
-    }
-    // Render the engine's phase updates as one in-place progress bar (percentage +
-    // running status) instead of the raw mongodump chatter; warnings are collected
-    // and flushed AFTER the bar closes so they never corrupt the in-place render.
-    const bar = createProgressBar({ label: 'Backing up' });
-    const warnings = [];
-    const result = await backup({
-        base,
-        creds,
-        network,
-        onProgress: (update) => bar.update(update.percent, update.message),
-        onWarn: (message) => warnings.push(message),
-    });
-    bar.done();
-    for (const warning of warnings)
-        progress(`⚠️  ${warning}`);
-    // Snapshot SQL too, when the scenario runs it: refresh the seed's `.bak` from the
-    // live database so the seed is a complete, re-restorable artifact (Mongo + SQL).
-    // Nothing to do when SQL is off, or when the seed ships no `.bak` to refresh (SQL
-    // was never seeded from this scenario — `findBackupFile` returns null; there is no
-    // database name to snapshot against). Its own progress bar mirrors the Mongo one.
-    let sqlBackupPath = null;
-    if (sqlEnabled) {
-        const bakFile = await findBackupFile(join(base, 'seed', 'sqlbackup'));
-        if (bakFile) {
-            progress(`Backing up SQL Server to "${bakFile}"…`);
-            const sqlBar = createProgressBar({ label: 'Backing up SQL' });
-            await snapshotSql({
-                base,
-                bakFile,
-                project,
-                saPassword: DEFAULT_SQL_SA_PASSWORD,
-                onProgress: (update) => sqlBar.update(update.percent, update.message),
-            });
-            sqlBar.done();
-            sqlBackupPath = join(base, 'seed', 'sqlbackup', bakFile);
-        }
-        else {
-            progress('⚠️  SQL is enabled but seed/sqlbackup holds no .bak to refresh — skipping the SQL snapshot.');
-        }
-    }
-    const parts = ['seed/dump (mongo)'];
-    if (result.dsFiles > 0)
-        parts.push(`seed/dsdata (${result.dsFiles} document-store files)`);
-    if (result.automationEntries > 0)
-        parts.push('seed/automation');
-    if (result.keyEntries > 0)
-        parts.push('seed/keys (encryption keys)');
-    if (result.configFiles > 0)
-        parts.push('seed/config (base configuration)');
-    if (sqlBackupPath)
-        parts.push('seed/sqlbackup (sql)');
-    progress(`Seed snapshot updated: ${parts.join(', ')}.`);
-    const backupResult = {
-        dumpPath: join(base, 'seed', 'dump'),
-        dsdataPath: result.dsFiles > 0 ? join(base, 'seed', 'dsdata') : null,
-        automationPath: result.automationEntries > 0 ? join(base, 'seed', 'automation') : null,
-        keysPath: result.keyEntries > 0 ? join(base, 'seed', 'keys') : null,
-        configPath: result.configFiles > 0 ? join(base, 'seed', 'config') : null,
-        sqlBackupPath,
-        dsFiles: result.dsFiles,
-        automationEntries: result.automationEntries,
-        keyEntries: result.keyEntries,
-        configFiles: result.configFiles,
-    };
-    // The backup brought `mongo` (and `sql`, when enabled) up on its own to run the
-    // dump/snapshot. Now that it's done, leave the environment as we found it: if the
-    // stack is NOT in a running state — the `jarvis` proxy is down, which is exactly
-    // how `lib/status` defines "running" — then those containers were started solely
-    // for this backup, so stop them. When the stack IS running, they belong to it and
-    // must stay up. `listComposeServices` is a read-only `docker ps` probe.
-    const running = await listComposeServices(project);
-    if (!running.includes('jarvis')) {
-        progress('Stopping the containers started only for this backup…');
-        await composeStop({ project, template, envFile, services: startupServices });
-    }
-    return backupResult;
-}
-/**
- * Register the `backup` subcommand on the commander program (wired by `cli.ts`).
- * `folder` is an optional positional defaulting to CWD.
- */
-export function registerBackupCommand(program) {
-    program
-        .command('backup [folder]')
-        .description("Snapshot the running scenario's Mongo data, document-store files, automation assets " +
-        'and base config files into the seed folder (replaces the previous snapshot).')
-        .action(async (folder) => {
-        await runBackup({ folder });
-    });
-}
-//# sourceMappingURL=backup.js.map
+var q=Object.defineProperty;var i=(r,e)=>q(r,"name",{value:e,configurable:!0});import{writeFileSync as B}from"node:fs";import{join as a}from"node:path";import{composeUp as j,composeStop as L,listComposeServices as D}from"../lib/docker.js";import{fetchListDatabases as Q,isJarvisDataPresent as $}from"../lib/mongo.js";import{generateEnv as C,readMongoCreds as M,templatePath as N,DEFAULT_SQL_SA_PASSWORD as _}from"../lib/compose.js";import{backup as x}from"../lib/backup.js";import{findBackupFile as A,snapshotSql as R}from"../lib/sql.js";import{readState as T,defaultProjectName as U,envFilePath as W}from"../lib/state.js";import{resolveScenario as G}from"../lib/scenario.js";import{progress as o,createProgressBar as P}from"../lib/progress.js";async function J(r={}){const e=G(r.folder),f=M(e),l=await T(e);if(l===null)throw new Error(`No started stack found for "${e}" (no .orchestrator/state.json). Run \`jarvis-launcher start\` first, then \`backup\`.`);const c=l.projectName??U(e),m=`${c}_default`,h=l.enabledProfiles??[],u=h.includes("sql"),g=u?["mongo","sql"]:["mongo"],k=N(),p=W(e),v=C({base:e,state:l,tag:"latest",profiles:h});B(p,v),o(u?"Starting MongoDB and SQL Server \u2014 waiting until they are up\u2026":"Starting MongoDB \u2014 waiting until it is healthy\u2026"),await j({project:c,template:k,envFile:p,services:g,wait:!0,authGate:!1}),o("Checking that the database has data to back up\u2026");const F=await Q({creds:f,network:m});if(!$(F))throw new Error("Nothing to back up: the scenario database is empty. The existing seed folder was left untouched.");const b=P({label:"Backing up"}),S=[],t=await x({base:e,creds:f,network:m,onProgress:i(s=>b.update(s.percent,s.message),"onProgress"),onWarn:i(s=>S.push(s),"onWarn")});b.done();for(const s of S)o(`\u26A0\uFE0F  ${s}`);let d=null;if(u){const s=await A(a(e,"seed","sqlbackup"));if(s){o(`Backing up SQL Server to "${s}"\u2026`);const w=P({label:"Backing up SQL"});await R({base:e,bakFile:s,project:c,saPassword:_,onProgress:i(y=>w.update(y.percent,y.message),"onProgress")}),w.done(),d=a(e,"seed","sqlbackup",s)}else o("\u26A0\uFE0F  SQL is enabled but seed/sqlbackup holds no .bak to refresh \u2014 skipping the SQL snapshot.")}const n=["seed/dump (mongo)"];t.dsFiles>0&&n.push(`seed/dsdata (${t.dsFiles} document-store files)`),t.automationEntries>0&&n.push("seed/automation"),t.keyEntries>0&&n.push("seed/keys (encryption keys)"),t.configFiles>0&&n.push("seed/config (base configuration)"),d&&n.push("seed/sqlbackup (sql)"),o(`Seed snapshot updated: ${n.join(", ")}.`);const E={dumpPath:a(e,"seed","dump"),dsdataPath:t.dsFiles>0?a(e,"seed","dsdata"):null,automationPath:t.automationEntries>0?a(e,"seed","automation"):null,keysPath:t.keyEntries>0?a(e,"seed","keys"):null,configPath:t.configFiles>0?a(e,"seed","config"):null,sqlBackupPath:d,dsFiles:t.dsFiles,automationEntries:t.automationEntries,keyEntries:t.keyEntries,configFiles:t.configFiles};return(await D(c)).includes("jarvis")||(o("Stopping the containers started only for this backup\u2026"),await L({project:c,template:k,envFile:p,services:g})),E}i(J,"runBackup");function ae(r){r.command("backup [folder]").description("Snapshot the running scenario's Mongo data, document-store files, automation assets and base config files into the seed folder (replaces the previous snapshot).").action(async e=>{await J({folder:e})})}i(ae,"registerBackupCommand");export{ae as registerBackupCommand,J as runBackup};

package/dist/commands/delete.js

@@ -0,0 +1 @@
+var a=Object.defineProperty;var n=(t,e)=>a(t,"name",{value:e,configurable:!0});import{confirm as s}from"@inquirer/prompts";import{destroyComposeProject as l}from"../lib/docker.js";import{readState as c,defaultProjectName as d}from"../lib/state.js";import{resolveScenario as m,configState as f,emptyScenarioFolder as u}from"../lib/scenario.js";import{progress as i}from"../lib/progress.js";function p(t,e){return`This will permanently DELETE the "${t}" environment: its docker containers, data volumes and network, plus ALL files in "${e}" (the folder will be emptied, including external-service folders and any backups stored there). Docker images are kept. This cannot be undone. Continue?`}n(p,"deleteConfirmationMessage");async function h(t,e){if(!process.stdin.isTTY)throw new Error(`Refusing to delete the environment "${t}" without confirmation. Re-run with --yes to delete non-interactively. Nothing was deleted.`);return s({message:p(t,e),default:!1})}n(h,"promptDeleteConfirmation");async function w(t){const e=m(t.folder),r=await c(e);if(r===null&&f(e)==="absent")throw new Error(`Nothing to delete: "${e}" is not a Jarvis environment (no config and no .orchestrator/state.json).`);const o=r?.projectName||d(e);if(!t.yes&&!await(t.confirmDeletion??h)(o,e))throw new Error("Aborted: nothing was deleted.");return i(`Deleting the "${o}" docker environment (containers, data volumes, network)\u2026`),await l(o),i(`Removing all files in "${e}"\u2026`),u(e),i("Deleted. Docker images are kept (they are shared between environments)."),{project:o,base:e}}n(w,"runDelete");function $(t){return t.command("delete").description("Permanently delete the environment: docker containers, data volumes and network, plus all files in the scenario folder. Docker images are kept.").argument("[folder]","scenario folder (defaults to the current directory)").option("--yes","skip the confirmation prompt (required for non-interactive use)").action(async(e,r)=>{await w({folder:e,yes:r.yes})})}n($,"registerDeleteCommand");export{p as deleteConfirmationMessage,$ as registerDeleteCommand,w as runDelete};

package/dist/commands/enable.js

@@ -1,169 +1 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
-import { readState, writeState, defaultProjectName, envFilePath } from '../lib/state.js';
-import { generateEnv, templatePath, DEFAULT_SQL_SA_PASSWORD } from '../lib/compose.js';
-import { composeUp } from '../lib/docker.js';
-import { allocateAttachedPorts } from '../lib/ports.js';
-import { OPTIONAL_PROFILE_PORTS } from '../lib/profiles.js';
-import { findBackupFile, seedSql } from '../lib/sql.js';
-import { progress, createProgressBar } from '../lib/progress.js';
-/**
- * commands/enable.ts — attach an optional service (`sql` | `mail`) to a scenario
- * (T-2-19).
- *
- * `enable [folder] <sql|mail>`:
- *  1. resolve the folder (default CWD) → project name from persisted state;
- *  2. add the requested profile to `state.enabledProfiles` and persist it
- *     (so a not-yet-running stack activates it on the next `start`);
- *  3. regenerate `<base>/.orchestrator/.env` with the updated `COMPOSE_PROFILES`;
- *  4. `docker compose up -d <service>` scoped to **only** the optional service —
- *     which attaches it to the existing project **without recreating** the core
- *     `jarvis`/`mongo`/`es` containers (FR-ORC-042);
- *  5. for `sql`: when `<base>/seed/sqlbackup` holds a `.bak`, run the SQL-seed flow
- *     (FR-ORC-029); with no `.bak` the container is still started and reachable
- *     but not seeded (FR-ORC-028).
- *
- * `mail` (FR-ORC-030) needs no seed step — its env wiring already lives in
- * `compose.generateEnv` (T-2-11); enabling the profile is enough to activate the
- * mail container + those vars.
- *
- * The SQL-seed *logic* (`buildRestoreSql`, the `.bak`-presence guard, the live
- * `seedSql` flow) lives in `lib/sql.ts` — a pure, unit-tested seam plus a
- * DEFERRED live integration half — so BOTH `enable sql` and `start --sql` reuse
- * it without importing one another.
- *
- * This command imports only `lib/*` — never another command (the command files
- * stay mutually independent so the phase builds in parallel).
- */
-/**
- * Ensure `ports` carries a host port for every port the enabled `service`
- * publishes ({@link OPTIONAL_PROFILE_PORTS}), allocating only the ones not already
- * persisted (idempotent — a re-`enable` keeps the existing port and never rebinds).
- * New ports slot into the scenario's contiguous base+offset block when free
- * (base = the persisted proxy port), else an OS-assigned free port. Returns `ports`
- * unchanged when all are already present. This is what backs the persisted
- * `state.ports.sql`/`mailUi` so the container binds a known host port AND the
- * homepage status header can surface the service's port + connect URL (without it
- * the `.env` port renders empty, the container binds a random host port, and the
- * header drops the row).
- */
-async function ensurePortsFor(ports, service) {
-    const needed = OPTIONAL_PROFILE_PORTS[service].filter(({ stateKey }) => ports[stateKey] === undefined);
-    if (needed.length === 0) {
-        return ports;
-    }
-    const allocated = await allocateAttachedPorts(ports.proxy, needed.map(({ portKey }) => portKey));
-    const next = { ...ports };
-    for (const { portKey, stateKey } of needed) {
-        next[stateKey] = allocated[portKey];
-    }
-    return next;
-}
-/**
- * Enable an optional service on a scenario stack — see the module doc for the
- * ordered behavior. Persists the profile, regenerates `.env`, and (when running)
- * attaches the single service without recreating the core stack; for `sql`,
- * seeds from `<base>/seed/sqlbackup` when a `.bak` is present.
- */
-export async function enable(options) {
-    const { service, start = true } = options;
-    const seedSqlImpl = options.seedSqlImpl ?? seedSql;
-    const base = resolve(options.folder ?? process.cwd());
-    // 1. Read state (regenerable; absent ⇒ stack never started). Derive the
-    //    project name from state or the folder default.
-    const existing = await readState(base);
-    const projectName = existing?.projectName ?? defaultProjectName(base);
-    // The stack is "running" only when it has been started (persisted state with a
-    // real port block exists). With no state we must never synthesize placeholder
-    // `0` ports nor `composeUp` (that would publish an invalid `0:80`); we only
-    // record the profile so the next `start` activates it — regardless of the
-    // `start` flag the caller passed (FR-ORC-042, T-2-19).
-    const stackRunning = existing !== null;
-    const shouldStart = start && stackRunning;
-    // 2. Add the profile to the persisted set (idempotent) and persist.
-    const previousProfiles = existing?.enabledProfiles ?? [];
-    const enabledProfiles = previousProfiles.includes(service)
-        ? previousProfiles
-        : [...previousProfiles, service];
-    // Carry the persisted ports when the stack is running, reserving a stable host
-    // port for the newly-enabled service (so the container binds a known port and the
-    // homepage status header can surface it — FR-ORC-042). When the stack is NOT
-    // running, persist an EMPTY port map: the next `start` re-probes, finds no real
-    // always-on ports, and allocates the whole block. Never synthesize placeholder
-    // `0` ports — a `0:80` publish is invalid and a persisted `0` would be reused.
-    let ports = existing?.ports ?? {};
-    if (shouldStart) {
-        ports = await ensurePortsFor(ports, service);
-    }
-    // Spread `existing` first so fields `enable` does not touch — notably the pinned
-    // image `tag` (and any future additive state) — survive; then override only the
-    // three this command owns. Dropping them would silently unpin the tag, so the
-    // next tag-less `start` falls back to `latest`. `{...null}` is `{}`, so this is
-    // also correct when the stack was never started.
-    const nextState = {
-        ...existing,
-        projectName,
-        ports,
-        enabledProfiles,
-    };
-    await writeState(base, nextState);
-    // When the stack is not running yet, persist-only: the profile activates on the
-    // next `start`. Nothing is brought up now.
-    if (!shouldStart) {
-        progress(`Enabled the "${service}" service — it will start on the next \`start\`.`);
-        return;
-    }
-    // 3. Regenerate the `.env` next to the persisted state with the updated
-    //    profiles so `COMPOSE_PROFILES` activates the optional container. Ensure
-    //    `.orchestrator/` exists (a not-yet-started folder may lack it).
-    const envFile = envFilePath(base);
-    await mkdir(dirname(envFile), { recursive: true });
-    const env = generateEnv({
-        base,
-        state: nextState,
-        tag: 'latest',
-        profiles: enabledProfiles,
-    });
-    await writeFile(envFile, env, 'utf8');
-    const template = templatePath();
-    // 4. Attach ONLY the optional service — scoped `up -d <service>` does NOT
-    //    recreate the always-on jarvis/mongo/es (FR-ORC-042).
-    //
-    //    Both optional services this command can enable are PUBLIC images (`sql` →
-    //    mcr.microsoft.com/mssql/server, `mail` → axllent/mailpit) and never pull the
-    //    authenticated `jarvis-dev` image, so skip the registry auth gate. Gating here
-    //    would probe the ACR against the default canary — the possibly-unpublished
-    //    `jarvis-dev:latest[-arm]` — and abort with a spurious "could not reach the
-    //    image registry" (`no such manifest`) even though nothing this up touches the
-    //    ACR (see ComposeUpOptions.authGate).
-    progress(`Starting the "${service}" container — waiting until it is healthy…`);
-    await composeUp({
-        project: projectName,
-        template,
-        envFile,
-        services: [service],
-        wait: true,
-        authGate: false,
-    });
-    // 5. SQL seeding (FR-ORC-029): only when a `.bak` is present. No `.bak` ⇒ the
-    //    container is up + reachable but not seeded (FR-ORC-028).
-    if (service === 'sql') {
-        const bakFile = await findBackupFile(join(base, 'seed', 'sqlbackup'));
-        if (bakFile) {
-            progress(`Seeding SQL Server from "${basename(bakFile)}"…`);
-            // Render the seed's phases as a single in-place progress bar (percentage +
-            // status), mirroring the Mongo restore, rather than the raw `sqlcmd` chatter.
-            const bar = createProgressBar({ label: 'Restoring SQL' });
-            await seedSqlImpl({
-                base,
-                bakFile,
-                project: projectName,
-                saPassword: DEFAULT_SQL_SA_PASSWORD,
-                onProgress: (update) => bar.update(update.percent, update.message),
-            });
-            bar.done();
-        }
-    }
-    progress(`The "${service}" service is ready.`);
-}
-//# sourceMappingURL=enable.js.map
+var v=Object.defineProperty;var n=(r,e)=>v(r,"name",{value:e,configurable:!0});import{mkdir as b,writeFile as F}from"node:fs/promises";import{basename as y,dirname as j,join as k,resolve as x}from"node:path";import{readState as L,writeState as R,defaultProjectName as q,envFilePath as A}from"../lib/state.js";import{generateEnv as O,templatePath as _,DEFAULT_SQL_SA_PASSWORD as E}from"../lib/compose.js";import{composeUp as I}from"../lib/docker.js";import{allocateAttachedPorts as N}from"../lib/ports.js";import{OPTIONAL_PROFILE_PORTS as T}from"../lib/profiles.js";import{findBackupFile as $,seedSql as Q}from"../lib/sql.js";import{progress as i,createProgressBar as B}from"../lib/progress.js";async function D(r,e){const o=T[e].filter(({stateKey:t})=>r[t]===void 0);if(o.length===0)return r;const c=await N(r.proxy,o.map(({portKey:t})=>t)),a={...r};for(const{portKey:t,stateKey:s}of o)a[s]=c[t];return a}n(D,"ensurePortsFor");async function Y(r){const{service:e,start:o=!0}=r,c=r.seedSqlImpl??Q,a=x(r.folder??process.cwd()),t=await L(a),s=t?.projectName??q(a),d=o&&t!==null,l=t?.enabledProfiles??[],u=l.includes(e)?l:[...l,e];let m=t?.ports??{};d&&(m=await D(m,e));const S={...t,projectName:s,ports:m,enabledProfiles:u};if(await R(a,S),!d){i(`Enabled the "${e}" service \u2014 it will start on the next \`start\`.`);return}const f=A(a);await b(j(f),{recursive:!0});const g=O({base:a,state:S,tag:"latest",profiles:u});await F(f,g,"utf8");const h=_();if(i(`Starting the "${e}" container \u2014 waiting until it is healthy\u2026`),await I({project:s,template:h,envFile:f,services:[e],wait:!0,authGate:!1}),e==="sql"){const p=await $(k(a,"seed","sqlbackup"));if(p){i(`Seeding SQL Server from "${y(p)}"\u2026`);const w=B({label:"Restoring SQL"});await c({base:a,bakFile:p,project:s,saPassword:E,onProgress:n(P=>w.update(P.percent,P.message),"onProgress")}),w.done()}}i(`The "${e}" service is ready.`)}n(Y,"enable");export{Y as enable};