jarvis-launcher 1.2.0-alpha.7 → 1.2.0

package/dist/cli.js

@@ -1,155 +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 { registerDeleteCommand } from './commands/delete.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, delete.
-//   * `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);
-registerDeleteCommand(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 version).
-program
-    .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 (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

@@ -1,74 +1 @@
-import { confirm } from '@inquirer/prompts';
-import { destroyComposeProject } from '../lib/docker.js';
-import { readState, defaultProjectName } from '../lib/state.js';
-import { resolveScenario, configState, emptyScenarioFolder } from '../lib/scenario.js';
-import { progress } from '../lib/progress.js';
-/**
- * The one confirmation wording, shared by the CLI gate and the homepage
- * collector so the integrator reads the identical blast-radius statement on
- * both front-ends.
- */
-export function deleteConfirmationMessage(project, base) {
-    return (`This will permanently DELETE the "${project}" environment: its docker containers, ` +
-        `data volumes and network, plus ALL files in "${base}" (the folder will be emptied, ` +
-        `including external-service folders and any backups stored there). ` +
-        `Docker images are kept. This cannot be undone. Continue?`);
-}
-/**
- * Default {@link DeleteOptions.confirmDeletion}: ask the integrator to confirm
- * (default No). Non-interactive runs (no TTY) fail fast with an actionable
- * message — nothing has been deleted at this point.
- */
-async function promptDeleteConfirmation(project, base) {
-    if (!process.stdin.isTTY) {
-        throw new Error(`Refusing to delete the environment "${project}" without confirmation. ` +
-            `Re-run with --yes to delete non-interactively. Nothing was deleted.`);
-    }
-    return confirm({ message: deleteConfirmationMessage(project, base), default: false });
-}
-/**
- * Permanently delete the environment — docker footprint first, then the folder
- * contents. See module docs. Throws (→ non-zero exit via `cli.ts`) when the
- * folder was never a Jarvis environment, when the integrator declines, or when
- * the docker teardown fails (in which case NOTHING on disk has been touched).
- */
-export async function runDelete(options) {
-    const base = resolveScenario(options.folder);
-    const state = await readState(base);
-    if (state === null && configState(base) === 'absent') {
-        throw new Error(`Nothing to delete: "${base}" is not a Jarvis environment ` +
-            `(no config and no .orchestrator/state.json).`);
-    }
-    const project = state?.projectName || defaultProjectName(base);
-    if (!options.yes) {
-        const confirmed = await (options.confirmDeletion ?? promptDeleteConfirmation)(project, base);
-        if (!confirmed) {
-            throw new Error('Aborted: nothing was deleted.');
-        }
-    }
-    // Docker first: if this throws (engine unreachable), state.json survives so
-    // the delete can be retried — and no container still holds the bind-mounts
-    // when the folder is emptied below.
-    progress(`Deleting the "${project}" docker environment (containers, data volumes, network)…`);
-    await destroyComposeProject(project);
-    progress(`Removing all files in "${base}"…`);
-    emptyScenarioFolder(base);
-    progress('Deleted. Docker images are kept (they are shared between environments).');
-    return { project, base };
-}
-/**
- * Register the `delete` subcommand on the given commander program. Wired up by
- * the entry point in T-2-23 (commands never import each other or the entry point).
- */
-export function registerDeleteCommand(program) {
-    return program
-        .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 (folder, opts) => {
-        await runDelete({ folder, yes: opts.yes });
-    });
-}
-//# sourceMappingURL=delete.js.map
+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};