@elmohq/cli 0.2.9 → 0.2.11

package/README.md

@@ -44,7 +44,7 @@ Requires [Docker](https://docs.docker.com/get-docker/) and Docker Compose.
 elmo init
 
 # 2. Start the stack
-elmo start
+elmo compose up -d
 
 # 3. Open the app at http://localhost:1515
 ```
@@ -58,29 +58,27 @@ For the full self-hosting walkthrough, see the [Elmo docs](https://www.elmohq.co
 | Command | Description |
 | --- | --- |
 | `elmo init` | Interactive wizard to set up a local Elmo instance |
-| `elmo start` | Start the Elmo stack |
-| `elmo stop` | Stop the Elmo stack |
-| `elmo status` | Check the health of running services |
-| `elmo logs [service]` | Tail container logs (pass `-f` to follow) |
-| `elmo regen` | Regenerate `elmo.yaml` / `.env` from your saved config |
-| `elmo compose <args...>` | Run any `docker compose` command against your Elmo project |
-| `elmo build` | Build Docker images locally (for `--dev` installs) |
+| `elmo compose <args...>` | Run any `docker compose` command against your Elmo project (e.g. `elmo compose up -d`, `elmo compose down`, `elmo compose logs -f`, `elmo compose build`, `elmo compose ps`) |
+| `elmo edit <env\|compose>` | Change API keys, scrape targets, or the Docker Compose YAML |
 
 Run `elmo --help` or `elmo <command> --help` for the full list of flags.
 
 ### Useful flags
 
-- `--dir <path>` — point any command at a specific config directory (defaults to `~/.config/elmo`).
+- `--dir <path>` — point any command at a specific config directory (defaults to `~/.elmo`).
 - `elmo init --dev` — build images from a local checkout of the repo instead of pulling from the registry.
 
 ## Telemetry
 
-The CLI sends anonymous install and command events so we can understand which flows people use and where setup breaks. To opt out, set:
+The CLI sends anonymous install and command events so we can understand which flows people use and where setup breaks. To opt out, either export `DISABLE_TELEMETRY=1` in your shell, or add it to your `.env`:
 
 ```bash
-export DISABLE_TELEMETRY=1
+elmo edit env       # add DISABLE_TELEMETRY=1
+elmo compose up -d  # restart so the deployment picks it up
 ```
 
+See [the telemetry docs](https://www.elmohq.com/docs/developer-guide/telemetry) for details on what is collected.
+
 ## Star, contribute, and chat
 
 Elmo is built in the open and we'd love your help.

package/dist/index.js

@@ -7,15 +7,15 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as p from "@clack/prompts";
 import { Command } from "commander";
+import { parse as parseDotenv } from "dotenv";
 import pc from "picocolors";
 import semver from "semver";
-import { getTelemetryStatus, setTelemetryEnabled, submitNewsletterSignup, trackCliEvent } from "./telemetry.js";
+import { submitNewsletterSignup, trackCliEvent } from "./telemetry.js";
 // ── Constants ────────────────────────────────────────────────────────────────
-const CONFIG_HOME = path.join(os.homedir(), ".config", "elmo");
-const CONFIG_FILE = path.join(CONFIG_HOME, "config.json");
+const CONFIG_HOME = path.join(os.homedir(), ".elmo");
 const DEFAULT_APP_NAME = "Elmo";
 const DEFAULT_APP_ICON = "/icons/elmo-icon.svg";
-const DEFAULT_APP_URL = "http://localhost:1515";
+const DEFAULT_APP_PORT = 1515;
 const LOCAL_DATABASE_URL = "postgres://postgres:postgres@postgres:5432/elmo";
 const TELEMETRY_DOC_URL = "https://elmohq.com/docs/developer-guide/telemetry";
 // ── Banner ───────────────────────────────────────────────────────────────────
@@ -64,6 +64,8 @@ async function main() {
     program
         .name("elmo")
         .version(version)
+        .option("--dir <path>", "Config directory")
+        .configureHelp({ showGlobalOptions: true })
         .action(() => {
         printBanner();
         program.outputHelp();
@@ -72,115 +74,27 @@ async function main() {
         .command("init")
         .description("set up local Elmo instance")
         .option("--dev", "Use local build context (repo only)")
-        .option("--dir <path>", "Directory to store config files")
         .option("--docker-dir <path>", "Path to Docker build context (dev mode)")
-        .action(async (options) => {
-        await withVersionCheck(version, () => runInit(options, version));
-    });
-    program
-        .command("regen")
-        .description("regenerate configuration files from current settings")
-        .option("--dir <path>", "Config directory")
-        .action(async (options) => {
-        await withVersionCheck(version, () => runRegen(options));
-    });
-    program
-        .command("start")
-        .description("start Elmo instance")
-        .option("--dir <path>", "Config directory")
-        .action(async (options) => {
-        await withVersionCheck(version, () => runStart(options));
-    });
-    program
-        .command("stop")
-        .description("stop Elmo instance")
-        .option("--dir <path>", "Config directory")
-        .action(async (options) => {
-        await withVersionCheck(version, () => runStop(options));
-    });
-    program
-        .command("status")
-        .description("check Elmo instance health")
-        .option("--dir <path>", "Config directory")
-        .action(async (options) => {
-        await withVersionCheck(version, () => runStatus(options));
+        .action(async (_opts, cmd) => {
+        await withVersionCheck(version, () => runInit(cmd.optsWithGlobals(), version));
     });
     program
         .command("compose")
         .description("run Docker Compose commands using your Elmo config")
         .allowUnknownOption(true)
-        .option("--dir <path>", "Config directory")
         .argument("[args...]", "Arguments passed to Docker Compose")
-        .action(async (args, options) => {
-        await withVersionCheck(version, () => runCompose(args, options));
+        .action(async (args, _opts, cmd) => {
+        await withVersionCheck(version, () => runCompose(args, cmd.optsWithGlobals()));
     });
     program
-        .command("logs")
-        .description("view Elmo instance logs")
-        .allowUnknownOption(true)
-        .option("--dir <path>", "Config directory")
-        .argument("[args...]", "Arguments passed to Docker Compose logs")
-        .action(async (args, options) => {
-        await withVersionCheck(version, () => runCompose(["logs", ...args], options));
-    });
-    program
-        .command("build")
-        .description("build Docker images locally for development")
-        .option("--dir <path>", "Config directory")
-        .option("--web-only", "Only build the web image")
-        .option("--worker-only", "Only build the worker image")
-        .option("--no-cache", "Build without Docker cache")
-        .action(async (options) => {
-        await withVersionCheck(version, () => runBuild(options));
-    });
-    const telemetry = program.command("telemetry").description("manage CLI + local-deployment telemetry");
-    telemetry
-        .command("status")
-        .description("show whether telemetry is enabled and what is collected")
-        .action(async () => {
-        await runTelemetryStatus();
-    });
-    telemetry
-        .command("enable")
-        .description("enable telemetry")
-        .action(async () => {
-        await setTelemetryEnabled(true);
-        const updated = await updateDeploymentEnvTelemetry(true);
-        log.success("Telemetry enabled.");
-        if (updated) {
-            log.info(`Updated ${updated}. Restart the stack with \`elmo start\` to apply.`);
-        }
-        console.log(`  Details: ${link(pc.cyan(TELEMETRY_DOC_URL), TELEMETRY_DOC_URL)}`);
-    });
-    telemetry
-        .command("disable")
-        .description("disable telemetry")
-        .action(async () => {
-        await setTelemetryEnabled(false);
-        const updated = await updateDeploymentEnvTelemetry(false);
-        log.success("Telemetry disabled. No further events will be sent.");
-        if (updated) {
-            log.info(`Updated ${updated}. Restart the stack with \`elmo start\` to apply.`);
-        }
+        .command("edit")
+        .description("change API keys, scrape targets, or the Docker Compose YAML")
+        .argument("<env|compose>", "which config file to edit")
+        .action(async (target, _opts, cmd) => {
+        await runEdit(target, cmd.optsWithGlobals());
     });
     await program.parseAsync(process.argv);
 }
-async function runTelemetryStatus() {
-    const status = await getTelemetryStatus();
-    const state = status.enabled ? pc.green("enabled") : pc.yellow("disabled");
-    console.log(`Telemetry: ${state}`);
-    if (status.source === "env") {
-        console.log("  Source: DISABLE_TELEMETRY environment variable");
-    }
-    else if (status.source === "config") {
-        console.log(`  Source: ${CONFIG_FILE}`);
-    }
-    if (status.distinctId) {
-        console.log(`  Install ID: ${status.distinctId}`);
-    }
-    console.log(`  What we collect: ${link(pc.cyan(TELEMETRY_DOC_URL), TELEMETRY_DOC_URL)}`);
-    console.log("  Toggle: `elmo telemetry enable` / `elmo telemetry disable`");
-}
 async function withVersionCheck(version, fn) {
     const notifyPromise = maybeNotifyNewVersion(version);
     await fn();
@@ -192,24 +106,13 @@ async function runInit(options, version) {
     p.intro(pc.bold("Setting up Elmo"));
     const cwd = process.cwd();
     // ── Resolve config directory ─────────────────────────────────────────
-    let configDir;
-    if (options.dir) {
-        configDir = path.resolve(cwd, options.dir);
-    }
-    else {
-        const dir = await p.text({
-            message: "Where should the config be stored?",
-            placeholder: "./elmo",
-            defaultValue: "./elmo",
-        });
-        assertNotCancelled(dir);
-        configDir = path.resolve(cwd, dir);
-    }
+    const configDir = options.dir ? path.resolve(cwd, options.dir) : CONFIG_HOME;
     // ── .env safety check ────────────────────────────────────────────────
     const existingEnvPath = path.join(configDir, ".env");
+    let preservedDeploymentId;
     if (await fileExists(existingEnvPath)) {
         const contents = await fs.readFile(existingEnvPath, "utf8");
-        const isElmoEnv = contents.startsWith("# Generated by elmo");
+        const isElmoEnv = contents.startsWith("# Rendered by elmo") || contents.startsWith("# Generated by elmo");
         if (!isElmoEnv) {
             p.log.warn(`A .env file already exists in ${configDir} and was NOT created by Elmo.`);
             const overwrite = await p.confirm({
@@ -223,7 +126,17 @@ async function runInit(options, version) {
             }
         }
         else {
-            p.log.info("Existing Elmo config found — it will be updated.");
+            p.log.warn(`An existing Elmo config was found at ${configDir}.`);
+            const overwrite = await p.confirm({
+                message: "Overwrite it with new values? Existing secrets (DATABASE_URL, API keys, etc.) will be replaced.",
+                initialValue: false,
+            });
+            assertNotCancelled(overwrite);
+            if (!overwrite) {
+                p.cancel("Setup cancelled. Use `elmo edit env` to change individual values.");
+                process.exit(0);
+            }
+            preservedDeploymentId = parseDotenv(contents).DEPLOYMENT_ID;
         }
     }
     // ── Dev mode: resolve docker directory ───────────────────────────────
@@ -264,14 +177,12 @@ async function runInit(options, version) {
     const env = {};
     env.DEPLOYMENT_MODE = "local";
     env.VITE_DEPLOYMENT_MODE = "local";
-    env.DEPLOYMENT_ID = crypto.randomUUID();
+    env.DEPLOYMENT_ID = preservedDeploymentId ?? crypto.randomUUID();
     env.BETTER_AUTH_SECRET = generateSecret();
     env.APP_NAME = DEFAULT_APP_NAME;
     env.APP_ICON = DEFAULT_APP_ICON;
-    env.APP_URL = DEFAULT_APP_URL;
     env.VITE_APP_NAME = DEFAULT_APP_NAME;
     env.VITE_APP_ICON = DEFAULT_APP_ICON;
-    env.VITE_APP_URL = DEFAULT_APP_URL;
     if (postgresMode === "external") {
         p.note("Must be an IPv4-compatible direct connection or database pooler.", "DATABASE_URL");
         const url = await p.password({
@@ -296,7 +207,7 @@ async function runInit(options, version) {
         "on what to fix or build next.",
         "",
         pc.bold("What we send:"),
-        "  • install ID (random UUID stored in ~/.config/elmo/config.json)",
+        "  • deployment ID (random UUID stored as DEPLOYMENT_ID in your .env)",
         "  • CLI/app version, OS, arch, Node version, deployment mode",
         "  • command/event names + non-secret options (e.g. postgres mode)",
         "  • feature counts (prompts edited, brands created — never the names or text)",
@@ -306,14 +217,13 @@ async function runInit(options, version) {
         "  API keys, .env contents, brand names, prompt text, and scraped responses.",
         "",
         `Full breakdown: ${link(pc.cyan(TELEMETRY_DOC_URL), TELEMETRY_DOC_URL)}`,
-        "Toggle later with `elmo telemetry enable|disable`.",
+        "Toggle later by editing DISABLE_TELEMETRY in .env (`elmo edit env`).",
     ].join("\n"), "Telemetry");
     const telemetryEnabled = await p.confirm({
         message: "Share telemetry?",
         initialValue: true,
     });
     assertNotCancelled(telemetryEnabled);
-    await setTelemetryEnabled(telemetryEnabled);
     if (!telemetryEnabled) {
         env.DISABLE_TELEMETRY = "1";
     }
@@ -323,12 +233,33 @@ async function runInit(options, version) {
         placeholder: "you@example.com",
     });
     const email = p.isCancel(updatesEmail) ? undefined : updatesEmail || undefined;
+    // ── Web app port ────────────────────────────────────────────────────
+    const portInput = await p.text({
+        message: "Web app port",
+        placeholder: String(DEFAULT_APP_PORT),
+        defaultValue: String(DEFAULT_APP_PORT),
+        validate: (v) => {
+            if (!v)
+                return undefined;
+            const n = Number(v);
+            if (!Number.isInteger(n) || n < 1 || n > 65535) {
+                return "Must be an integer between 1 and 65535";
+            }
+            return undefined;
+        },
+    });
+    assertNotCancelled(portInput);
+    const port = Number(portInput);
+    env.APP_URL = `http://localhost:${port}`;
+    env.VITE_APP_URL = env.APP_URL;
     // ── Write config ─────────────────────────────────────────────────────
     const composeYaml = buildComposeYaml({
         dev: Boolean(options.dev),
         postgresMode,
         repoRoot,
         dockerDir,
+        port,
+        version,
     });
     await ensureDir(configDir);
     await writeConfigFiles(configDir, {
@@ -336,13 +267,7 @@ async function runInit(options, version) {
         composeYaml,
         postgresMode,
         dev: Boolean(options.dev),
-    });
-    await writeGlobalConfig({
-        configDir,
-        dockerDir,
-        dev: Boolean(options.dev),
-        postgresMode,
-        repoRoot,
+        version,
     });
     p.log.success(`Config written to ${configDir}`);
     p.log.warn("Your generated .env file contains secrets — do not commit it to version control.");
@@ -358,10 +283,10 @@ async function runInit(options, version) {
         await doStart(configDir);
     }
     else {
-        p.log.info("You can start later with `elmo start`.");
+        p.log.info("You can start later with `elmo compose up -d`.");
     }
     // CLI telemetry — silently dropped if the user opted out above.
-    await trackCliEvent("cli_init", {
+    await trackCliEvent(configDir, "cli_init", {
         version,
         os: process.platform,
         arch: process.arch,
@@ -375,7 +300,7 @@ async function runInit(options, version) {
     // Newsletter signup is a separate, explicit opt-in and runs even when
     // telemetry is disabled.
     if (email) {
-        await submitNewsletterSignup(email);
+        await submitNewsletterSignup(configDir, email);
     }
     p.log.message(`If you find Elmo useful, star us on GitHub!\n  ${link(pc.cyan("https://github.com/elmohq/elmo"), "https://github.com/elmohq/elmo")}`);
     p.outro(pc.green("Setup complete!"));
@@ -460,7 +385,7 @@ async function configureProvidersRecommended(env) {
         initialValue: "openrouter",
     });
     assertNotCancelled(direct);
-    await collectDirectApiQuick(direct, env, targets);
+    await collectDirectApiQuick(direct, env);
     await finalizeScrapeTargets(env, targets, { skipEdit: true });
 }
 async function configureProvidersCustom(env) {
@@ -506,7 +431,7 @@ async function collectScraperKey(scraper, env) {
         env.OLOSTEP_API_KEY = key;
     }
 }
-async function collectDirectApiQuick(kind, env, targets) {
+async function collectDirectApiQuick(kind, env) {
     if (kind === "openrouter") {
         const key = await p.password({
             message: "OpenRouter API key",
@@ -514,7 +439,6 @@ async function collectDirectApiQuick(kind, env, targets) {
         });
         assertNotCancelled(key);
         env.OPENROUTER_API_KEY = key;
-        targets.push(`claude:openrouter:${DEFAULT_OPENROUTER_MODEL}:online`);
     }
     else if (kind === "anthropic") {
         const key = await p.password({
@@ -523,7 +447,6 @@ async function collectDirectApiQuick(kind, env, targets) {
         });
         assertNotCancelled(key);
         env.ANTHROPIC_API_KEY = key;
-        targets.push(`claude:anthropic-api:${DEFAULT_ANTHROPIC_MODEL}:online`);
     }
     else if (kind === "openai") {
         const key = await p.password({
@@ -532,7 +455,6 @@ async function collectDirectApiQuick(kind, env, targets) {
         });
         assertNotCancelled(key);
         env.OPENAI_API_KEY = key;
-        targets.push(`chatgpt:openai-api:${DEFAULT_OPENAI_MODEL}:online`);
     }
     else {
         const key = await p.password({
@@ -541,7 +463,6 @@ async function collectDirectApiQuick(kind, env, targets) {
         });
         assertNotCancelled(key);
         env.MISTRAL_API_KEY = key;
-        targets.push(`mistral:mistral-api:${DEFAULT_MISTRAL_MODEL}:online`);
     }
 }
 async function collectBrightData(env, targets) {
@@ -797,51 +718,7 @@ function dedupeTargets(targets) {
     }
     return out.join(",");
 }
-// ── Command: update ──────────────────────────────────────────────────────────
-async function runRegen(options) {
-    const configDir = await resolveConfigDir(options.dir);
-    const globalConfig = await readGlobalConfig();
-    // Determine settings: prefer global config, fall back to detecting from files
-    let dev;
-    let postgresMode;
-    let repoRoot;
-    let dockerDir;
-    if (globalConfig?.postgresMode) {
-        dev = globalConfig.dev ?? false;
-        postgresMode = globalConfig.postgresMode;
-        repoRoot = globalConfig.repoRoot ?? process.cwd();
-        dockerDir = globalConfig.dockerDir;
-    }
-    else {
-        const detected = await detectSettingsFromConfig(configDir);
-        dev = detected.dev;
-        postgresMode = detected.postgresMode;
-        repoRoot = detected.repoRoot;
-        dockerDir = detected.dockerDir;
-    }
-    const composeYaml = buildComposeYaml({
-        dev,
-        postgresMode,
-        repoRoot,
-        dockerDir,
-    });
-    const composePath = path.join(configDir, "elmo.yaml");
-    await fs.writeFile(composePath, composeYaml, "utf8");
-    await writeGlobalConfig({
-        configDir,
-        dockerDir,
-        dev,
-        postgresMode,
-        repoRoot,
-    });
-    log.success(`Regenerated ${composePath}`);
-    log.info("The .env file was not modified.");
-}
-// ── Command: start ───────────────────────────────────────────────────────────
-async function runStart(options) {
-    const configDir = await resolveConfigDir(options.dir);
-    await doStart(configDir);
-}
+// ── Start helper (used by init) ──────────────────────────────────────────────
 async function doStart(configDir) {
     assertDockerRunning();
     log.step("Starting Docker Compose stack...");
@@ -857,71 +734,48 @@ async function doStart(configDir) {
         p.log.warn("Some services did not report healthy status.");
     }
     log.info("Examples:");
-    console.log(`  ${pc.bold("elmo logs -f")}`);
+    console.log(`  ${pc.bold("elmo compose logs -f")}`);
     console.log(`  ${pc.bold("elmo compose logs -f web")}`);
     console.log(`  ${pc.bold("elmo compose ps")}`);
+    console.log(`  ${pc.bold("elmo compose down")}`);
 }
-// ── Command: stop ────────────────────────────────────────────────────────────
-async function runStop(options) {
+// ── Command: compose ─────────────────────────────────────────────────────────
+async function runCompose(args, options) {
     const configDir = await resolveConfigDir(options.dir);
     assertDockerRunning();
-    log.step("Stopping Docker Compose stack...");
-    await runDockerCompose(configDir, ["down"]);
-    log.success("Stack stopped.");
+    await runDockerCompose(configDir, args);
 }
-// ── Command: status ──────────────────────────────────────────────────────────
-async function runStatus(options) {
+// ── Command: edit ────────────────────────────────────────────────────────────
+async function runEdit(target, options) {
     const configDir = await resolveConfigDir(options.dir);
-    assertDockerRunning();
-    const services = await getComposeServices(configDir);
-    if (services.length === 0) {
-        log.warn("No running services found.");
-        return;
-    }
-    let allHealthy = true;
-    for (const service of services) {
-        const status = formatServiceStatus(service);
-        console.log(status);
-        if (!isServiceReady(service)) {
-            allHealthy = false;
-        }
+    let filePath;
+    if (target === "env") {
+        filePath = path.join(configDir, ".env");
     }
-    if (allHealthy) {
-        log.success("All services are healthy.");
+    else if (target === "compose") {
+        filePath = path.join(configDir, "elmo.yaml");
     }
     else {
-        log.warn("Some services are not healthy yet.");
+        throw new Error(`Unknown edit target: ${target}. Use \`env\` or \`compose\`.`);
     }
-}
-// ── Command: compose ─────────────────────────────────────────────────────────
-async function runCompose(args, options) {
-    const configDir = await resolveConfigDir(options.dir);
-    assertDockerRunning();
-    await runDockerCompose(configDir, args);
-}
-// ── Command: build ───────────────────────────────────────────────────────────
-async function runBuild(options) {
-    const configDir = await resolveConfigDir(options.dir);
-    assertDockerRunning();
-    const buildWeb = !options.workerOnly;
-    const buildWorker = !options.webOnly;
-    const noCache = options.cache === false;
-    const targets = [];
-    if (buildWeb)
-        targets.push("web");
-    if (buildWorker)
-        targets.push("worker");
-    log.step(`Building Docker images: ${targets.join(", ")}${noCache ? " (no cache)" : ""}...`);
-    const buildArgs = ["build"];
-    if (noCache)
-        buildArgs.push("--no-cache");
-    for (const target of targets) {
-        log.step(`Building ${target}...`);
-        await runDockerCompose(configDir, [...buildArgs, target]);
-        log.success(`${target} image built successfully.`);
+    if (!(await fileExists(filePath))) {
+        throw new Error(`File not found: ${filePath}`);
     }
-    log.success("All images built.");
-    console.log(`  Run ${pc.bold("elmo start")} to start the stack.`);
+    const editorEnv = process.env.VISUAL || process.env.EDITOR || "nano";
+    const parts = editorEnv.split(/\s+/).filter(Boolean);
+    const cmd = parts[0] ?? "nano";
+    const args = [...parts.slice(1), filePath];
+    await new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: "inherit" });
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${cmd} exited with code ${code}`));
+        });
+        child.on("error", (err) => reject(err));
+    });
+    log.info("Restart the stack with `elmo compose up -d` to apply changes.");
 }
 // ── Compose YAML Builder ─────────────────────────────────────────────────────
 function buildComposeYaml(options) {
@@ -942,6 +796,7 @@ function buildComposeYaml(options) {
             dev: options.dev,
             dockerfilePath,
             repoRoot: options.repoRoot,
+            version: options.version,
         }));
         dependsOnWeb.push("db-migrate");
         dependsOnWorker.push("db-migrate");
@@ -953,6 +808,8 @@ function buildComposeYaml(options) {
         dependencyConditions,
         repoRoot: options.repoRoot,
         dockerfilePath,
+        port: options.port,
+        version: options.version,
     }));
     services.push(buildWorkerService({
         dev: options.dev,
@@ -960,8 +817,9 @@ function buildComposeYaml(options) {
         dependencyConditions,
         repoRoot: options.repoRoot,
         dockerfilePath,
+        version: options.version,
     }));
-    const lines = ["name: elmo", "", "services:"];
+    const lines = [renderedByHeader(options.version), "", "name: elmo", "", "services:"];
     lines.push(...services.map((service) => indentBlock(service, 2)));
     if (volumes.size > 0) {
         lines.push("", "volumes:");
@@ -997,7 +855,7 @@ function buildDbMigrateService(options) {
         lines.push("  build:", `    context: ${options.repoRoot}`, `    dockerfile: ${options.dockerfilePath}`, "    target: migrate");
     }
     else {
-        lines.push("  image: elmohq/elmo-db-migrate:latest");
+        lines.push(`  image: elmohq/elmo-db-migrate:${options.version}`);
     }
     lines.push("  environment:", "    - DATABASE_URL=postgres://postgres:postgres@postgres:5432/elmo", "  depends_on:", "    postgres:", "      condition: service_healthy");
     return lines.join("\n");
@@ -1008,9 +866,9 @@ function buildWebService(options) {
         lines.push("  build:", `    context: ${options.repoRoot}`, `    dockerfile: ${options.dockerfilePath}`, "    target: web", "    args:", "      DEPLOYMENT_MODE: local");
     }
     else {
-        lines.push("  image: elmohq/elmo-web:latest");
+        lines.push(`  image: elmohq/elmo-web:${options.version}`);
     }
-    lines.push("  env_file:", "    - path: .env", "      required: true", "  ports:", '    - "1515:3000"');
+    lines.push("  env_file:", "    - path: .env", "      required: true", "  ports:", `    - "${options.port}:3000"`);
     if (options.dependsOn.length > 0) {
         lines.push("  depends_on:");
         for (const service of options.dependsOn) {
@@ -1026,7 +884,7 @@ function buildWorkerService(options) {
         lines.push("  build:", `    context: ${options.repoRoot}`, `    dockerfile: ${options.dockerfilePath}`, "    target: worker", "    args:", "      DEPLOYMENT_MODE: local");
     }
     else {
-        lines.push("  image: elmohq/elmo-worker:latest");
+        lines.push(`  image: elmohq/elmo-worker:${options.version}`);
     }
     lines.push("  env_file:", "    - path: .env", "      required: true");
     if (options.dependsOn.length > 0) {
@@ -1076,19 +934,6 @@ async function getComposeServices(configDir) {
         }
     }
 }
-function formatServiceStatus(service) {
-    const health = service.Health ?? "unknown";
-    const state = service.State ?? "unknown";
-    const label = `${service.Service}`.padEnd(16, " ");
-    let color = pc.red;
-    if (isServiceReady(service)) {
-        color = pc.green;
-    }
-    else if (health === "starting" || state.includes("starting")) {
-        color = pc.yellow;
-    }
-    return color(`${label} ${state} ${service.Health ? `(${health})` : ""}`.trim());
-}
 function isServiceReady(service) {
     if (service.Health) {
         return service.Health === "healthy";
@@ -1196,52 +1041,32 @@ async function resolveDockerDirAuto(cwd, explicitDir) {
 }
 // ── Config Dir Resolution ────────────────────────────────────────────────────
 async function resolveConfigDir(explicitDir) {
-    if (explicitDir) {
-        const resolved = path.resolve(process.cwd(), explicitDir);
-        const composePath = path.join(resolved, "elmo.yaml");
-        if (!(await fileExists(composePath))) {
-            throw new Error(`Config directory does not contain elmo.yaml: ${resolved}\nRun \`elmo init\` to create your local setup.`);
-        }
-        return resolved;
-    }
-    const config = await readGlobalConfig();
-    if (!config?.configDir) {
-        throw new Error("No config found. Run `elmo init` or specify --dir.");
-    }
-    const resolved = path.resolve(config.configDir);
+    const resolved = explicitDir ? path.resolve(process.cwd(), explicitDir) : CONFIG_HOME;
     const composePath = path.join(resolved, "elmo.yaml");
     if (!(await fileExists(composePath))) {
-        throw new Error(`Config directory does not contain elmo.yaml: ${resolved}\nRun \`elmo init\` to regenerate.`);
+        if (explicitDir) {
+            throw new Error(`Config directory does not contain elmo.yaml: ${resolved}\nRun \`elmo init --dir ${explicitDir}\` to create it.`);
+        }
+        throw new Error(`No config found at ${resolved}. Run \`elmo init\` to create one, or specify --dir.`);
     }
     return resolved;
 }
 // ── File & Config Helpers ────────────────────────────────────────────────────
-async function readGlobalConfig() {
-    try {
-        const contents = await fs.readFile(CONFIG_FILE, "utf8");
-        return JSON.parse(contents);
-    }
-    catch {
-        return null;
-    }
-}
-async function writeGlobalConfig(config) {
-    const globalConfig = {
-        ...config,
-        updatedAt: new Date().toISOString(),
-    };
-    await ensureDir(CONFIG_HOME);
-    await fs.writeFile(CONFIG_FILE, JSON.stringify(globalConfig, null, 2), "utf8");
-}
 async function writeConfigFiles(configDir, initConfig) {
     const envPath = path.join(configDir, ".env");
     const composePath = path.join(configDir, "elmo.yaml");
     await ensureDir(configDir);
-    await fs.writeFile(envPath, buildEnvFile(initConfig.env), "utf8");
+    await fs.writeFile(envPath, buildEnvFile(initConfig.env, initConfig.version), "utf8");
     await fs.writeFile(composePath, initConfig.composeYaml, "utf8");
 }
-function buildEnvFile(env) {
-    const lines = ["# Generated by elmo init", "# WARNING: contains secrets. Do not commit.", ""];
+function renderedByHeader(version) {
+    return [
+        `# Rendered by elmo ${version} on ${new Date().toISOString()}`,
+        "# Re-run `elmo init` after upgrading the CLI to refresh this file.",
+    ].join("\n");
+}
+function buildEnvFile(env, version) {
+    const lines = [renderedByHeader(version), "# WARNING: contains secrets. Do not commit.", ""];
     for (const [key, rawValue] of Object.entries(env)) {
         if (rawValue === undefined) {
             continue;
@@ -1260,68 +1085,6 @@ function formatEnvValue(value) {
     }
     return value;
 }
-async function detectSettingsFromConfig(configDir) {
-    const envPath = path.join(configDir, ".env");
-    const env = await readEnvFile(envPath);
-    const postgresMode = env.DATABASE_URL?.includes("postgres:5432") ? "docker" : "external";
-    const yamlPath = path.join(configDir, "elmo.yaml");
-    let dev = false;
-    let repoRoot = process.cwd();
-    try {
-        const yamlContent = await fs.readFile(yamlPath, "utf8");
-        dev = yamlContent.includes("build:");
-        const contextMatch = yamlContent.match(/context:\s+(.+)/);
-        if (contextMatch) {
-            repoRoot = contextMatch[1].trim();
-        }
-    }
-    catch {
-        // Use defaults
-    }
-    return { dev, postgresMode, repoRoot };
-}
-async function updateDeploymentEnvTelemetry(enabled) {
-    const config = await readGlobalConfig();
-    if (!config?.configDir)
-        return null;
-    const envPath = path.join(config.configDir, ".env");
-    if (!(await fileExists(envPath)))
-        return null;
-    const contents = await fs.readFile(envPath, "utf8");
-    const lines = contents.split("\n");
-    const filtered = lines.filter((line) => !/^\s*DISABLE_TELEMETRY\s*=/.test(line));
-    if (!enabled) {
-        const insertIdx = filtered.length > 0 && filtered[filtered.length - 1] === "" ? filtered.length - 1 : filtered.length;
-        filtered.splice(insertIdx, 0, "DISABLE_TELEMETRY=1");
-    }
-    await fs.writeFile(envPath, filtered.join("\n"), "utf8");
-    return envPath;
-}
-async function readEnvFile(envPath) {
-    try {
-        const contents = await fs.readFile(envPath, "utf8");
-        const env = {};
-        for (const line of contents.split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith("#"))
-                continue;
-            const eqIndex = trimmed.indexOf("=");
-            if (eqIndex < 0)
-                continue;
-            const key = trimmed.substring(0, eqIndex);
-            let value = trimmed.substring(eqIndex + 1);
-            // Remove surrounding quotes
-            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-                value = value.slice(1, -1);
-            }
-            env[key] = value;
-        }
-        return env;
-    }
-    catch {
-        return {};
-    }
-}
 async function fileExists(target) {
     try {
         await fs.access(target);

package/dist/telemetry.js

@@ -1,67 +1,33 @@
-import crypto from "node:crypto";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
+import { parse } from "dotenv";
 import { PostHog } from "posthog-node";
 const POSTHOG_PUBLIC_KEY = "phc_Jhx9LnI9cTDFHpQmpOzJSDTW127qD9pFU65KRnYym6z";
 const POSTHOG_HOST = "https://us.i.posthog.com";
-const CONFIG_HOME = path.join(os.homedir(), ".config", "elmo");
-const CONFIG_FILE = path.join(CONFIG_HOME, "config.json");
-async function readConfig() {
+function envDisabled() {
+    return Boolean(process.env.DISABLE_TELEMETRY);
+}
+async function readEnvKey(configDir, key) {
     try {
-        const contents = await fs.readFile(CONFIG_FILE, "utf8");
-        return JSON.parse(contents);
+        const contents = await fs.readFile(path.join(configDir, ".env"), "utf8");
+        return parse(contents)[key];
     }
     catch {
-        return {};
+        return undefined;
     }
 }
-async function writeConfig(config) {
-    await fs.mkdir(CONFIG_HOME, { recursive: true });
-    await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf8");
-}
-function envDisabled() {
-    return Boolean(process.env.DISABLE_TELEMETRY);
-}
-export async function isTelemetryDisabled() {
+async function isTelemetryDisabled(configDir) {
     if (envDisabled())
         return true;
-    const config = await readConfig();
-    return config.telemetryDisabled === true;
+    return Boolean(await readEnvKey(configDir, "DISABLE_TELEMETRY"));
 }
-export async function setTelemetryEnabled(enabled) {
-    const config = await readConfig();
-    if (enabled) {
-        delete config.telemetryDisabled;
-    }
-    else {
-        config.telemetryDisabled = true;
-    }
-    await writeConfig(config);
-}
-export async function getTelemetryStatus() {
-    if (envDisabled()) {
-        return { enabled: false, source: "env" };
-    }
-    const config = await readConfig();
-    if (config.telemetryDisabled === true) {
-        return { enabled: false, source: "config", distinctId: config.telemetryId };
-    }
-    return { enabled: true, source: "default", distinctId: config.telemetryId };
-}
-async function getOrCreateDistinctId() {
-    const config = await readConfig();
-    if (config.telemetryId)
-        return config.telemetryId;
-    const id = crypto.randomUUID();
-    await writeConfig({ ...config, telemetryId: id });
-    return id;
-}
-export async function trackCliEvent(eventName, properties, personProperties) {
-    if (await isTelemetryDisabled())
+export async function trackCliEvent(configDir, eventName, properties, personProperties) {
+    if (await isTelemetryDisabled(configDir))
+        return;
+    const distinctId = await readEnvKey(configDir, "DEPLOYMENT_ID");
+    if (!distinctId)
         return;
     try {
-        const distinctId = await getOrCreateDistinctId();
         const client = new PostHog(POSTHOG_PUBLIC_KEY, { host: POSTHOG_HOST });
         client.capture({
             distinctId,
@@ -77,14 +43,15 @@ export async function trackCliEvent(eventName, properties, personProperties) {
 }
 // Newsletter signup is an explicit user action with clear intent, so it
 // fires even when anonymous telemetry is disabled. When telemetry is on the
-// event is keyed off the install UUID and the email is attached as a person
-// property — same identity as the rest of the CLI events. When telemetry is
-// off the event is keyed off the email itself, so it is never linked back
-// to the anonymous install UUID.
-export async function submitNewsletterSignup(email) {
+// event is keyed off the deployment UUID and the email is attached as a
+// person property — same identity as the rest of the CLI events. When
+// telemetry is off the event is keyed off the email itself, so it is never
+// linked back to the anonymous deployment UUID.
+export async function submitNewsletterSignup(configDir, email) {
     try {
-        const disabled = await isTelemetryDisabled();
-        const distinctId = disabled ? email : await getOrCreateDistinctId();
+        const disabled = await isTelemetryDisabled(configDir);
+        const deploymentId = disabled ? null : await readEnvKey(configDir, "DEPLOYMENT_ID");
+        const distinctId = deploymentId ?? email;
         const client = new PostHog(POSTHOG_PUBLIC_KEY, { host: POSTHOG_HOST });
         client.capture({
             distinctId,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elmohq/cli",
-  "version": "0.2.9",
-  "license": "AGPL-3.0-or-later",
+  "version": "0.2.11",
+  "license": "MIT",
   "keywords": [
     "marketing",
     "typescript",
@@ -28,14 +28,15 @@
   ],
   "type": "module",
   "dependencies": {
-    "@clack/prompts": "^1.3.0",
-    "commander": "^14.0.3",
+    "@clack/prompts": "^1.5.0",
+    "commander": "^15.0.0",
+    "dotenv": "17.4.2",
     "picocolors": "^1.1.1",
-    "posthog-node": "^5.33.0",
-    "semver": "^7.7.4"
+    "posthog-node": "^5.35.6",
+    "semver": "^7.8.1"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
+    "@types/node": "^25.9.1",
     "@types/semver": "^7.7.1",
     "typescript": "^6.0.3"
   },