@django-stack/cli 0.7.0 → 0.8.1

package/README.md

@@ -14,6 +14,7 @@ docker compose up
 | `production [directory]` | Write `.env.production` for a server. Flags: `--domain`, `--email-url`, `--force`, `--yes` |
 | `preset [preset]` | Print the preset code of a stack, or the stack of a code |
 | `doctor [directory]` | Check a project and its running services |
+| `self-update` | Update `dstack` to the latest version, with the package manager that installed it |
 | `secret [bytes]` | Print a random secret |
 | `completion <shell>` | Print a Tab completion script for zsh, bash, fish or PowerShell |
 

package/dist/bin.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { A as generateSecret, B as isDockerDown, C as applies, D as resolvePreset, E as pendingChoices, F as portValues, H as quoteEnvValue, I as runDoctor, L as checkTools, M as chooseFreePorts, N as describeMove, O as stackOption, P as envPorts, R as dockerNotRunning, S as STACK_OPTIONS, T as encodePreset, U as setEnvValues, V as parseEnv, _ as validateTimeZone, a as LOCAL_S3, b as NAMED_PRESETS, c as lockBackend, d as scaffold, f as timeZones, g as validateProjectName, h as usesValkey, j as DEV_PORTS, k as generateProjectSecrets, m as umamiEnv, n as productionEnv$1, o as cacheEnv, p as toProjectName, r as validateDomain, s as localS3, t as missingS3, u as relativeDirectory, v as CLI_VERSION, w as decodePreset, x as PROMPT_ORDER, y as DEFAULT_STACK, z as dockerRunning } from "./production-DBpWWx6i.js";
+import { $ as isDockerDown, A as projectUrls, B as encodePreset, C as RUN_ENV, D as findProjectDirectory, E as composeOutput, F as NAMED_PRESETS, G as chooseFreePorts, H as resolvePreset, I as PROMPT_ORDER, J as portValues, K as describeMove, L as STACK_OPTIONS, M as readProject, N as runningServices, O as parseProfiles, P as DEFAULT_STACK, Q as dockerRunning, R as applies, S as RUN_DOMAIN, T as compose, U as stackOption, V as pendingChoices, W as DEV_PORTS, X as checkTools, Y as runDoctor, Z as dockerNotRunning, _ as validateTimeZone, a as LOCAL_S3, b as generateProjectSecrets, c as lockBackend, d as scaffold, et as parseEnv, f as timeZones, g as validateProjectName, h as usesValkey, j as readLocalRun, k as projectStack, m as umamiEnv, n as productionEnv$1, nt as setEnvValues, o as cacheEnv, p as toProjectName, q as envPorts, r as validateDomain, s as localS3, t as missingS3, tt as quoteEnvValue, u as relativeDirectory, v as CLI_VERSION, w as activeProject, x as generateSecret, y as PACKAGE_NAME } from "./production-CGkI7oNe.js";
 import { createRequire } from "node:module";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, relative, resolve } from "node:path";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import pc from "picocolors";
 import tab from "@bomb.sh/tab/commander";
 import * as p from "@clack/prompts";
@@ -2495,228 +2496,6 @@ function getProvider(id) {
 	if (!provider) throw new Error(`Unknown deploy provider ${id}. Choose one of: ${PROVIDERS.map((p) => p.id).join(", ")}.`);
 	return provider;
 }
-// src/project.ts
-/** The `.env` of `dstack run` on a development machine: the prod profile at https://site.localhost. */
-const RUN_ENV = ".env.run";
-const RUN_DOMAIN = "site.localhost";
-/** The project directory: `start` or the nearest parent with `compose.yaml` and `.env`. */
-function findProjectDirectory(start) {
-	let directory = resolve(start);
-	for (;;) {
-		if (existsSync(join(directory, "compose.yaml")) && existsSync(join(directory, ".env"))) return directory;
-		const parent = dirname(directory);
-		if (parent === directory) return void 0;
-		directory = parent;
-	}
-}
-function parseProfiles(value) {
-	return (value ?? "").split(",").map((profile) => profile.trim()).filter(Boolean);
-}
-function projectName(directory) {
-	try {
-		const match = readFileSync(join(directory, "compose.yaml"), "utf8").match(/^name:\s*["']?([\w.-]+)/m);
-		if (match?.[1]) return match[1];
-	} catch {}
-	return basename(directory).toLowerCase();
-}
-function fromEnv(directory, name, envFile, localRun) {
-	const env = parseEnv(readFileSync(join(directory, envFile), "utf8"));
-	const profiles = parseProfiles(env.COMPOSE_PROFILES);
-	const prod = profiles.includes("prod");
-	const suffix = prod ? "-prod" : "";
-	return {
-		directory,
-		name: localRun ? `${name}-run` : name,
-		env,
-		profiles,
-		prod,
-		localRun,
-		services: {
-			backend: `backend${suffix}`,
-			frontend: `frontend${suffix}`,
-			worker: `worker${suffix}`
-		},
-		composeArgs: localRun ? [
-			"--env-file",
-			envFile,
-			"--project-name",
-			`${name}-run`
-		] : [],
-		composeEnv: localRun ? {
-			ENV_FILE: envFile,
-			COMPOSE_PROFILES: env.COMPOSE_PROFILES ?? ""
-		} : {}
-	};
-}
-/** Reads the project in or above `start`. Throws with a one-line reason when there is none. */
-function readProject(start = ".") {
-	const directory = findProjectDirectory(start);
-	if (!directory) throw new Error(`No DjangoStack project in ${resolve(start)}: run this where compose.yaml and .env are.`);
-	return fromEnv(directory, projectName(directory), ".env", false);
-}
-/** The local production run of a development project, when `.env.run` exists. */
-function readLocalRun(project) {
-	if (project.prod || project.localRun || !existsSync(join(project.directory, ".env.run"))) return void 0;
-	return fromEnv(project.directory, projectName(project.directory), RUN_ENV, true);
-}
-/** The `django-stack` section of the project's `package.json`. */
-function projectManifest(project) {
-	try {
-		return JSON.parse(readFileSync(join(project.directory, "package.json"), "utf8"))["django-stack"] ?? {};
-	} catch {
-		return {};
-	}
-}
-/**
-* The project's stack: from the preset `init` saved in `package.json`, or,
-* for projects from before that, the defaults with the storage from `.env`.
-* Analytics follow the `analytics` profile: projects from before Umami was
-* generated have the default in their preset without running it.
-*/
-function projectStack(project) {
-	const fromEnv = {
-		analytics: project.profiles.includes("analytics") ? "umami" : "off",
-		...project.env.CACHE_URL === void 0 ? {} : cacheStack(project.env)
-	};
-	const { preset } = projectManifest(project);
-	if (preset) try {
-		return {
-			...decodePreset(preset),
-			...fromEnv
-		};
-	} catch {}
-	return {
-		...DEFAULT_STACK,
-		...fromEnv,
-		storage: project.profiles.includes("s3") ? "s3" : "local"
-	};
-}
-const REDIS = /^(redis|rediss|valkey|valkeys):/;
-/**
-* The cache and the tasks a project's `.env` runs. Projects from before 0.7
-* have no TASKS_URL: their tasks follow a Redis cache, like the backend does.
-*/
-function cacheStack(env) {
-	const cacheUrl = env.CACHE_URL ?? "";
-	const cache = cacheUrl.startsWith("db:") ? "database" : REDIS.test(cacheUrl) ? "valkey" : "off";
-	const tasksUrl = env.TASKS_URL || (cache === "valkey" ? cacheUrl : "immediate://");
-	if (tasksUrl.startsWith("immediate:")) return {
-		cache,
-		tasks: "off"
-	};
-	return {
-		cache,
-		tasks: REDIS.test(tasksUrl) && cache !== "valkey" ? "huey-valkey" : "huey"
-	};
-}
-/** The URLs of a running project. */
-function projectUrls(project) {
-	if (project.prod) {
-		const site = (project.env.SITE_URL ?? "").replace(/\/$/, "");
-		return [{
-			label: "Site",
-			url: `${site}/`
-		}, {
-			label: "Admin",
-			url: `${site}/admin/`
-		}];
-	}
-	const ports = envPorts(project.env);
-	const site = (project.env.SITE_URL || `http://localhost:${ports.SITE_PORT}`).replace(/\/$/, "");
-	const urls = [
-		{
-			label: "Site",
-			url: site
-		},
-		{
-			label: "Admin",
-			url: `${site}/admin/`
-		},
-		{
-			label: "Mail",
-			url: `http://localhost:${ports.MAIL_PORT}`
-		}
-	];
-	if (project.profiles.includes("s3")) urls.push({
-		label: "S3",
-		url: `http://localhost:${ports.S3_PORT}`
-	});
-	return urls;
-}
-/** Runs a command with the terminal attached and returns its exit status. */
-const runInherit = (cmd, args, options) => {
-	const result = spawnSync(cmd, args, {
-		stdio: "inherit",
-		...options
-	});
-	if (result.error) return 127;
-	return result.status ?? 1;
-};
-/** The full `docker compose` argument list for a project. */
-function composeCommand(project, args) {
-	return [
-		"compose",
-		...project.composeArgs,
-		...args
-	];
-}
-function composeOptions(project) {
-	return {
-		cwd: project.directory,
-		env: {
-			...process.env,
-			...project.composeEnv
-		}
-	};
-}
-/** Runs `docker compose <args>` for the project with the terminal attached. */
-function compose(project, args, run = runInherit) {
-	return run("docker", composeCommand(project, args), composeOptions(project));
-}
-/** Runs `docker compose <args>` and captures the output. */
-function composeOutput(project, args) {
-	const result = spawnSync("docker", composeCommand(project, args), {
-		...composeOptions(project),
-		encoding: "utf8",
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	return {
-		status: result.status ?? 1,
-		output: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
-	};
-}
-/** The running services of the project. */
-function runningServices(project) {
-	const result = spawnSync("docker", composeCommand(project, [
-		"ps",
-		"--services",
-		"--filter",
-		"status=running"
-	]), {
-		...composeOptions(project),
-		encoding: "utf8",
-		stdio: [
-			"ignore",
-			"pipe",
-			"ignore"
-		]
-	});
-	return result.status === 0 ? result.stdout.split("\n").filter(Boolean) : [];
-}
-/**
-* The project a command acts on: the local production run when it is the
-* one running, otherwise the project `.env` describes.
-*/
-function activeProject(project) {
-	const localRun = readLocalRun(project);
-	if (!localRun) return project;
-	if (runningServices(project).length) return project;
-	return runningServices(localRun).length ? localRun : project;
-}
 // src/ui.ts
 /** The DjangoStack badge with the version and an optional title. */
 function intro(title) {
@@ -3195,90 +2974,6 @@ async function doctor(directoryArgument) {
 	}
 	p.outro(pc.green("All checks passed"));
 }
-// src/update-check.ts
-const PACKAGE_NAME = "@django-stack/cli";
-const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-const DAY = 864e5;
-/** `$XDG_CACHE_HOME/django-stack/update-check.json`, or under `~/.cache`. */
-function defaultCachePath(env = process.env) {
-	const base = env.XDG_CACHE_HOME || process.platform === "win32" && env.LOCALAPPDATA || join(homedir(), ".cache");
-	return join(base, "django-stack", "update-check.json");
-}
-/** Whether to check at all: never in CI, without a terminal, or when turned off. */
-function updateCheckEnabled(env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
-	if (!isTTY) return false;
-	if (env.CI && env.CI !== "0" && env.CI !== "false") return false;
-	for (const key of ["DJANGO_STACK_NO_UPDATE_CHECK", "NO_UPDATE_NOTIFIER"]) if (env[key] && env[key] !== "0") return false;
-	return true;
-}
-function parse(version) {
-	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(version.trim());
-	if (!match) return void 0;
-	return [
-		Number(match[1]),
-		Number(match[2]),
-		Number(match[3]),
-		match[4] ?? ""
-	];
-}
-/** Whether `latest` is a newer version than `current`. Prereleases of `latest` never count. */
-function isNewer(latest, current) {
-	const a = parse(latest);
-	const b = parse(current);
-	if (!a || !b || a[3]) return false;
-	for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
-	return b[3] !== "";
-}
-function readCache(path) {
-	try {
-		const data = JSON.parse(readFileSync(path, "utf8"));
-		if (typeof data.checkedAt === "number" && typeof data.latest === "string") return data;
-	} catch {}
-}
-function writeCache(path, cache) {
-	try {
-		mkdirSync(dirname(path), { recursive: true });
-		writeFileSync(path, JSON.stringify(cache));
-	} catch {}
-}
-/**
-* The latest version on npm when it is newer than `current`, otherwise
-* undefined. Uses a cached result for a day; never throws.
-*/
-async function checkForUpdate(options) {
-	const cachePath = options.cachePath ?? defaultCachePath();
-	const now = options.now ?? Date.now;
-	const maxAge = options.maxAge ?? DAY;
-	let latest = readCache(cachePath);
-	if (!latest || now() - latest.checkedAt > maxAge || latest.checkedAt > now()) try {
-		const response = await (options.fetch ?? fetch)(REGISTRY_URL, {
-			headers: { accept: "application/json" },
-			signal: AbortSignal.timeout(options.timeout ?? 1500)
-		});
-		if (!response.ok) return void 0;
-		const { version } = await response.json();
-		if (typeof version !== "string") return void 0;
-		latest = {
-			checkedAt: now(),
-			latest: version
-		};
-		writeCache(cachePath, latest);
-	} catch {
-		return;
-	}
-	return isNewer(latest.latest, options.current) ? latest.latest : void 0;
-}
-/** The command that runs or installs the latest version, depending on how this one was started. */
-function updateCommand(location = import.meta.url, env = process.env) {
-	const path = decodeURIComponent(location).replaceAll("\\", "/");
-	if (path.includes("/_npx/")) return `npx ${PACKAGE_NAME}@latest`;
-	if (path.includes("/dlx/") || path.includes("/dlx-")) return `pnpm dlx ${PACKAGE_NAME}@latest`;
-	if (path.includes("/bunx-")) return `bunx ${PACKAGE_NAME}@latest`;
-	if (path.includes("/pnpm/global/")) return `pnpm add -g ${PACKAGE_NAME}@latest`;
-	if (path.includes("/.bun/install/global/")) return `bun add -g ${PACKAGE_NAME}@latest`;
-	if (env.npm_config_user_agent?.startsWith("pnpm")) return `pnpm add -g ${PACKAGE_NAME}@latest`;
-	return `npm i -g ${PACKAGE_NAME}@latest`;
-}
 // src/global-install.ts
 /** The name of the installed command. */
 const BIN = "dstack";
@@ -3297,6 +2992,37 @@ function temporaryRunner(location = import.meta.url) {
 	if (path.includes("/dlx/") || path.includes("/dlx-")) return "pnpm";
 	if (path.includes("/bunx-")) return "bun";
 }
+/** How this copy runs, and with which package manager, from where its files are. */
+function installation(location = import.meta.url, env = process.env) {
+	const temporary = temporaryRunner(location);
+	if (temporary) return {
+		kind: "temporary",
+		runner: temporary
+	};
+	const path = normalize(location);
+	if (!path.includes("/node_modules/")) return { kind: "checkout" };
+	const lower = path.toLowerCase();
+	if (lower.includes("/pnpm/global/")) return {
+		kind: "installed",
+		runner: "pnpm"
+	};
+	if (lower.includes("/.bun/install/global/")) return {
+		kind: "installed",
+		runner: "bun"
+	};
+	if (lower.includes("/yarn/global/") || lower.includes("/yarn/data/global/")) return {
+		kind: "installed",
+		runner: "yarn"
+	};
+	if (env.npm_config_user_agent?.startsWith("pnpm")) return {
+		kind: "installed",
+		runner: "pnpm"
+	};
+	return {
+		kind: "installed",
+		runner: "npm"
+	};
+}
 /** Whether `dstack` is on the `PATH`, leaving out the temporary directories npx and friends add. */
 function isOnPath(env = process.env, platform = process.platform) {
 	const names = platform === "win32" ? [
@@ -3321,6 +3047,12 @@ function installCommand(runner = "npm") {
 		"--global",
 		`${PACKAGE_NAME}@latest`
 	];
+	if (runner === "yarn") return [
+		"yarn",
+		"global",
+		"add",
+		`${PACKAGE_NAME}@latest`
+	];
 	return [
 		"npm",
 		"i",
@@ -3375,7 +3107,7 @@ function explainFailure(runner, output) {
 	const last = output.trim().split("\n").pop()?.trim();
 	return `${last ? `${last} ` : ""}Run ${manual} to try again.`;
 }
-function run$1(args) {
+function runInstall(args) {
 	return new Promise((resolve) => {
 		const [cmd, ...rest] = args;
 		let output = "";
@@ -3433,7 +3165,7 @@ async function offerGlobalInstall() {
 	}
 	const spinner = p.spinner();
 	spinner.start(`Installing with ${command(args.join(" "))}`);
-	const result = await run$1(args);
+	const result = await runInstall(args);
 	if (!result.ok) {
 		saveInstallAnswer("failed");
 		spinner.error(`Couldn't install ${BIN}`);
@@ -4437,7 +4169,8 @@ function checkSteps(project, tests) {
 }
 /** `dstack check`: the doctor's checks, Django's checks, the linters and, with --tests, the tests. */
 async function check(options) {
-	const project = activeProject(open(options));
+	const base = open(options);
+	const project = activeProject(base);
 	intro("Check");
 	let failed = 0;
 	const spinner = p.spinner();
@@ -4518,11 +4251,12 @@ async function update(options) {
 	} else if (existsSync(lock)) p.log.warn("uv is not installed, so backend/uv.lock stays as it is: https://docs.astral.sh/uv/");
 	for (const target of targets) {
 		if (compose(target, ["pull", "--ignore-buildable"]) !== 0) fail("Pulling the images failed.");
-		if (compose(target, [
+		const build = [
 			"build",
 			"--pull",
 			...options.cache ? [] : ["--no-cache"]
-		]) !== 0) fail("Building the images failed.");
+		];
+		if (compose(target, build) !== 0) fail("Building the images failed.");
 	}
 	const volume = project.prod ? void 0 : nodeModulesVolume(project);
 	if (volume) {
@@ -4593,12 +4327,184 @@ async function config(options) {
 	if (result.env === envText) p.outro(pc.green("Done"));
 	else p.outro(`Restart to apply it: ${command("dstack stop")}, then ${command("dstack dev")}`);
 }
+// src/update-check.ts
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const DAY = 864e5;
+/** `$XDG_CACHE_HOME/django-stack/update-check.json`, or under `~/.cache`. */
+function defaultCachePath(env = process.env) {
+	const base = env.XDG_CACHE_HOME || process.platform === "win32" && env.LOCALAPPDATA || join(homedir(), ".cache");
+	return join(base, "django-stack", "update-check.json");
+}
+/** Whether to check at all: never in CI, without a terminal, or when turned off. */
+function updateCheckEnabled(env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+	if (!isTTY) return false;
+	if (env.CI && env.CI !== "0" && env.CI !== "false") return false;
+	for (const key of ["DJANGO_STACK_NO_UPDATE_CHECK", "NO_UPDATE_NOTIFIER"]) if (env[key] && env[key] !== "0") return false;
+	return true;
+}
+function parse(version) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(version.trim());
+	if (!match) return void 0;
+	return [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3]),
+		match[4] ?? ""
+	];
+}
+/** Whether `latest` is a newer version than `current`. Prereleases of `latest` never count. */
+function isNewer(latest, current) {
+	const a = parse(latest);
+	const b = parse(current);
+	if (!a || !b || a[3]) return false;
+	for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
+	return b[3] !== "";
+}
+function readCache(path) {
+	try {
+		const data = JSON.parse(readFileSync(path, "utf8"));
+		if (typeof data.checkedAt === "number" && typeof data.latest === "string") return data;
+	} catch {}
+}
+function writeCache(path, cache) {
+	try {
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, JSON.stringify(cache));
+	} catch {}
+}
+/** The latest version on npm. Throws when the registry can't be reached. */
+async function fetchLatestVersion(options = {}) {
+	const response = await (options.fetch ?? fetch)(REGISTRY_URL, {
+		headers: { accept: "application/json" },
+		signal: AbortSignal.timeout(options.timeout ?? 1500)
+	});
+	if (!response.ok) throw new Error(`The npm registry answered ${response.status}.`);
+	const { version } = await response.json();
+	if (typeof version !== "string") throw new Error("The npm registry sent no version.");
+	return version;
+}
+/**
+* The latest version on npm when it is newer than `current`, otherwise
+* undefined. Uses a cached result for a day; never throws.
+*/
+async function checkForUpdate(options) {
+	const cachePath = options.cachePath ?? defaultCachePath();
+	const now = options.now ?? Date.now;
+	const maxAge = options.maxAge ?? DAY;
+	let latest = readCache(cachePath);
+	if (!latest || now() - latest.checkedAt > maxAge || latest.checkedAt > now()) try {
+		latest = {
+			checkedAt: now(),
+			latest: await fetchLatestVersion(options)
+		};
+		writeCache(cachePath, latest);
+	} catch {
+		return;
+	}
+	return isNewer(latest.latest, options.current) ? latest.latest : void 0;
+}
+/**
+* The command that gets the latest version: through the runner for npx,
+* pnpm dlx and bunx, otherwise `dstack self-update`.
+*/
+function updateCommand(location = import.meta.url, env = process.env) {
+	const install = installation(location, env);
+	if (install.kind === "temporary") {
+		if (install.runner === "pnpm") return `pnpm dlx ${PACKAGE_NAME}@latest`;
+		if (install.runner === "bun") return `bunx ${PACKAGE_NAME}@latest`;
+		return `npx ${PACKAGE_NAME}@latest`;
+	}
+	if (install.kind === "checkout") return "git pull";
+	return "dstack self-update";
+}
+// src/commands/self-update.ts
+/** The command each package manager runs a package with, without installing it. */
+const RUN_WITHOUT_INSTALL = {
+	npm: "npx",
+	pnpm: "pnpm dlx",
+	bun: "bunx",
+	yarn: "yarn dlx"
+};
+/**
+* The npm prefix this copy is installed in, such as `/usr/local` for
+* `/usr/local/lib/node_modules/@django-stack/cli`, so the update replaces this
+* copy even when another Node.js version's npm comes first on the `PATH`.
+*/
+function npmPrefix(location = import.meta.url) {
+	if (!location.startsWith("file:")) return void 0;
+	const path = fileURLToPath(location);
+	return /^(.+)\/lib\/node_modules\/@django-stack\/cli\//.exec(path)?.[1];
+}
+/** The version of the `dstack` on the `PATH`, or undefined when there is none. */
+function versionOnPath() {
+	try {
+		return execFileSync(BIN, ["--version"], {
+			encoding: "utf8",
+			shell: process.platform === "win32",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			env: {
+				...process.env,
+				DJANGO_STACK_NO_UPDATE_CHECK: "1"
+			}
+		}).trim();
+	} catch {
+		return;
+	}
+}
+/** Update the installed CLI to the latest version on npm, with the package manager that installed it. */
+async function selfUpdate() {
+	intro("Self-update");
+	const install = installation();
+	if (install.kind === "checkout") fail(`This ${BIN} runs from a DjangoStack checkout. Update it with git pull and pnpm build.`);
+	if (install.kind === "temporary") {
+		const runWith = RUN_WITHOUT_INSTALL[install.runner];
+		fail(`This ${BIN} runs through ${runWith} and is not installed. Run ${runWith} ${PACKAGE_NAME}@latest for the latest version, or install it with ${installCommand(install.runner).join(" ")}.`);
+	}
+	const { runner } = install;
+	const spinner = p.spinner();
+	spinner.start("Checking npm for the latest version");
+	let latest;
+	try {
+		latest = await fetchLatestVersion({ timeout: 1e4 });
+	} catch (error) {
+		spinner.error("Couldn't check npm");
+		fail(`Couldn't reach the npm registry: ${error.message}`);
+	}
+	if (!isNewer(latest, CLI_VERSION)) {
+		spinner.stop(`${BIN} ${CLI_VERSION} is the latest version`);
+		p.outro(pc.green("Nothing to update"));
+		return;
+	}
+	spinner.stop(`Version ${pc.green(pc.bold(latest))} is available`);
+	const prefix = runner === "npm" ? npmPrefix() : void 0;
+	const args = prefix ? [
+		...installCommand(runner),
+		"--prefix",
+		prefix
+	] : installCommand(runner);
+	if (!has(runner)) fail(`${runner} installed ${BIN} but is not on your PATH. Run ${args.join(" ")} yourself.`);
+	spinner.start(`Updating with ${command(args.join(" "))}`);
+	const result = await runInstall(args);
+	if (!result.ok) {
+		spinner.error(`Couldn't update ${BIN}`);
+		fail(explainFailure(runner, result.output));
+	}
+	spinner.stop(`Updated ${BIN} ${pc.dim(CLI_VERSION)} ${pc.dim("→")} ${pc.green(pc.bold(latest))}`);
+	const onPath = versionOnPath();
+	if (onPath && onPath !== latest) p.log.warn(`The ${command(BIN)} on your PATH is still ${onPath}: another install comes first. Remove it, or update it with its own package manager.`);
+	p.outro(pc.green("Done"));
+}
 // src/program.ts
-/** Commands that print machine-readable output, so no update notice. */
+/** Commands that print machine-readable output or update the CLI, so no update notice. */
 const QUIET_COMMANDS = /* @__PURE__ */ new Set([
 	"secret",
 	"complete",
-	"completion"
+	"completion",
+	"self-update"
 ]);
 /** A flag for each stack option, such as `--cache <cache>`. */
 function stackFlags() {
@@ -4670,6 +4576,7 @@ function createProgram() {
 	program.command("production").description("Write .env.production for a server").argument("[directory]", "The project directory", ".").option("--domain <domain>", "The domain of the site, such as example.com").option("--email-url <url>", "The SMTP server, such as smtp+tls://user:pass@host:587").option("--force", "Overwrite an existing .env.production").option("-y, --yes", "Don't ask; fail when --domain is missing").action(production);
 	program.command("settings").description("Ask for the missing production settings and credentials, and save them").addOption(dirOption()).option("--file <file>", "The file to change (default: .env.production, or .env on a server)").option("--set <NAME=value>", "Set a value without asking, such as --set ADMIN_EMAIL=you@example.com", (value, previous = []) => [...previous, value]).option("--all", "Ask for every setting, also the ones that are set").option("-y, --yes", "Don't ask; fail when a setting is still missing").action(settings);
 	program.command("doctor").description("Check a project and its services").argument("[directory]", "The project directory", ".").action(doctor);
+	program.command("self-update").description(`Update ${BIN} to the latest version on npm`).action(selfUpdate);
 	program.command("secret").description("Print a random secret").argument("[bytes]", "The number of random bytes", positiveInteger, 32).action((bytes) => console.log(generateSecret(bytes)));
 	tab(program, { completionCommandName: "completion" });
 	program.commands.find((cmd) => cmd.name() === "completion")?.description("Print a shell completion script (zsh, bash, fish or powershell)").addHelpText("after", `\nAdd it to your shell, for example in ~/.zshrc:\n  ${pc.cyan("source <(dstack completion zsh)")}`);

package/dist/index.js

@@ -1 +1 @@
-export { y as DEFAULT_STACK, i as FRONTENDS, b as NAMED_PRESETS, S as STACK_OPTIONS, v as VERSION, o as cacheEnv, w as decodePreset, T as encodePreset, k as generateProjectSecrets, A as generateSecret, l as normalizeDatabaseUrl, V as parseEnv, E as pendingChoices, n as productionEnv, D as resolvePreset, I as runDoctor, d as scaffold, U as setEnvValues, p as toProjectName, h as usesValkey, r as validateDomain, g as validateProjectName } from "./production-DBpWWx6i.js";
+export { P as DEFAULT_STACK, i as FRONTENDS, F as NAMED_PRESETS, L as STACK_OPTIONS, v as VERSION, o as cacheEnv, z as decodePreset, B as encodePreset, b as generateProjectSecrets, x as generateSecret, l as normalizeDatabaseUrl, et as parseEnv, V as pendingChoices, n as productionEnv, H as resolvePreset, Y as runDoctor, d as scaffold, nt as setEnvValues, p as toProjectName, h as usesValkey, r as validateDomain, g as validateProjectName } from "./production-CGkI7oNe.js";

package/dist/{production-DBpWWx6i.js → production-CGkI7oNe.js}

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
-import { execFileSync } from "node:child_process";
+import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
 import { randomBytes, randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { createConnection, createServer } from "node:net";
@@ -436,25 +436,6 @@ async function chooseFreePorts(env, profiles, isFree = isPortFree) {
 function describeMove(move) {
 	return `Port ${move.from} is in use, so the ${move.label} uses ${move.to}.`;
 }
-// src/secrets.ts
-/** A URL-safe random secret with `bytes` bytes of randomness. */
-function generateSecret(bytes = 32) {
-	return randomBytes(bytes).toString("base64url");
-}
-/** The secrets a project's .env needs, by the name used in `{{secret:<name>}}`. */
-function generateProjectSecrets() {
-	return {
-		django: generateSecret(48),
-		postgres: generateSecret(24),
-		api: generateSecret(32),
-		api_read: generateSecret(32),
-		preview: generateSecret(32),
-		revalidate: generateSecret(32),
-		admin: generateSecret(12),
-		umami_app: generateSecret(32),
-		umami_admin: generateSecret(24)
-	};
-}
 // src/stack.ts
 const STACK_OPTIONS = [
 	{
@@ -865,9 +846,270 @@ function pendingChoices(stack) {
 		}];
 	});
 }
+// src/project.ts
+/** The `.env` of `dstack run` on a development machine: the prod profile at https://site.localhost. */
+const RUN_ENV = ".env.run";
+const RUN_DOMAIN = "site.localhost";
+/**
+* The project's scripts that must be executable. npm and pnpm packages do
+* not keep the executable bit of non-bin files, so the templates arrive
+* without it.
+*/
+const EXECUTABLES = ["backend/entrypoint.sh", "backend/manage.py"];
+/** Makes the project's scripts executable for everyone who can read them. */
+function makeExecutable(directory) {
+	for (const file of EXECUTABLES) {
+		const path = join(directory, file);
+		try {
+			const { mode } = statSync(path);
+			const executable = mode | (mode & 292) >> 2;
+			if (executable !== mode) chmodSync(path, executable & 4095);
+		} catch {}
+	}
+}
+/** The project directory: `start` or the nearest parent with `compose.yaml` and `.env`. */
+function findProjectDirectory(start) {
+	let directory = resolve(start);
+	for (;;) {
+		if (existsSync(join(directory, "compose.yaml")) && existsSync(join(directory, ".env"))) return directory;
+		const parent = dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+function parseProfiles(value) {
+	return (value ?? "").split(",").map((profile) => profile.trim()).filter(Boolean);
+}
+function projectName(directory) {
+	try {
+		const match = readFileSync(join(directory, "compose.yaml"), "utf8").match(/^name:\s*["']?([\w.-]+)/m);
+		if (match?.[1]) return match[1];
+	} catch {}
+	return basename(directory).toLowerCase();
+}
+function fromEnv(directory, name, envFile, localRun) {
+	const env = parseEnv(readFileSync(join(directory, envFile), "utf8"));
+	const profiles = parseProfiles(env.COMPOSE_PROFILES);
+	const prod = profiles.includes("prod");
+	const suffix = prod ? "-prod" : "";
+	return {
+		directory,
+		name: localRun ? `${name}-run` : name,
+		env,
+		profiles,
+		prod,
+		localRun,
+		services: {
+			backend: `backend${suffix}`,
+			frontend: `frontend${suffix}`,
+			worker: `worker${suffix}`
+		},
+		composeArgs: localRun ? [
+			"--env-file",
+			envFile,
+			"--project-name",
+			`${name}-run`
+		] : [],
+		composeEnv: localRun ? {
+			ENV_FILE: envFile,
+			COMPOSE_PROFILES: env.COMPOSE_PROFILES ?? ""
+		} : {}
+	};
+}
+/** Reads the project in or above `start`. Throws with a one-line reason when there is none. */
+function readProject(start = ".") {
+	const directory = findProjectDirectory(start);
+	if (!directory) throw new Error(`No DjangoStack project in ${resolve(start)}: run this where compose.yaml and .env are.`);
+	makeExecutable(directory);
+	return fromEnv(directory, projectName(directory), ".env", false);
+}
+/** The local production run of a development project, when `.env.run` exists. */
+function readLocalRun(project) {
+	if (project.prod || project.localRun || !existsSync(join(project.directory, ".env.run"))) return void 0;
+	return fromEnv(project.directory, projectName(project.directory), RUN_ENV, true);
+}
+/** The `django-stack` section of the project's `package.json`. */
+function projectManifest(project) {
+	try {
+		return JSON.parse(readFileSync(join(project.directory, "package.json"), "utf8"))["django-stack"] ?? {};
+	} catch {
+		return {};
+	}
+}
+/**
+* The project's stack: from the preset `init` saved in `package.json`, or,
+* for projects from before that, the defaults with the storage from `.env`.
+* Analytics follow the `analytics` profile: projects from before Umami was
+* generated have the default in their preset without running it.
+*/
+function projectStack(project) {
+	const fromEnv = {
+		analytics: project.profiles.includes("analytics") ? "umami" : "off",
+		...project.env.CACHE_URL === void 0 ? {} : cacheStack(project.env)
+	};
+	const { preset } = projectManifest(project);
+	if (preset) try {
+		return {
+			...decodePreset(preset),
+			...fromEnv
+		};
+	} catch {}
+	return {
+		...DEFAULT_STACK,
+		...fromEnv,
+		storage: project.profiles.includes("s3") ? "s3" : "local"
+	};
+}
+const REDIS = /^(redis|rediss|valkey|valkeys):/;
+/**
+* The cache and the tasks a project's `.env` runs. Projects from before 0.7
+* have no TASKS_URL: their tasks follow a Redis cache, like the backend does.
+*/
+function cacheStack(env) {
+	const cacheUrl = env.CACHE_URL ?? "";
+	const cache = cacheUrl.startsWith("db:") ? "database" : REDIS.test(cacheUrl) ? "valkey" : "off";
+	const tasksUrl = env.TASKS_URL || (cache === "valkey" ? cacheUrl : "immediate://");
+	if (tasksUrl.startsWith("immediate:")) return {
+		cache,
+		tasks: "off"
+	};
+	return {
+		cache,
+		tasks: REDIS.test(tasksUrl) && cache !== "valkey" ? "huey-valkey" : "huey"
+	};
+}
+/** The URLs of a running project. */
+function projectUrls(project) {
+	if (project.prod) {
+		const site = (project.env.SITE_URL ?? "").replace(/\/$/, "");
+		return [{
+			label: "Site",
+			url: `${site}/`
+		}, {
+			label: "Admin",
+			url: `${site}/admin/`
+		}];
+	}
+	const ports = envPorts(project.env);
+	const site = (project.env.SITE_URL || `http://localhost:${ports.SITE_PORT}`).replace(/\/$/, "");
+	const urls = [
+		{
+			label: "Site",
+			url: site
+		},
+		{
+			label: "Admin",
+			url: `${site}/admin/`
+		},
+		{
+			label: "Mail",
+			url: `http://localhost:${ports.MAIL_PORT}`
+		}
+	];
+	if (project.profiles.includes("s3")) urls.push({
+		label: "S3",
+		url: `http://localhost:${ports.S3_PORT}`
+	});
+	return urls;
+}
+/** Runs a command with the terminal attached and returns its exit status. */
+const runInherit = (cmd, args, options) => {
+	const result = spawnSync(cmd, args, {
+		stdio: "inherit",
+		...options
+	});
+	if (result.error) return 127;
+	return result.status ?? 1;
+};
+/** The full `docker compose` argument list for a project. */
+function composeCommand(project, args) {
+	return [
+		"compose",
+		...project.composeArgs,
+		...args
+	];
+}
+function composeOptions(project) {
+	return {
+		cwd: project.directory,
+		env: {
+			...process.env,
+			...project.composeEnv
+		}
+	};
+}
+/** Runs `docker compose <args>` for the project with the terminal attached. */
+function compose(project, args, run = runInherit) {
+	return run("docker", composeCommand(project, args), composeOptions(project));
+}
+/** Runs `docker compose <args>` and captures the output. */
+function composeOutput(project, args) {
+	const result = spawnSync("docker", composeCommand(project, args), {
+		...composeOptions(project),
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	return {
+		status: result.status ?? 1,
+		output: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
+	};
+}
+/** The running services of the project. */
+function runningServices(project) {
+	const result = spawnSync("docker", composeCommand(project, [
+		"ps",
+		"--services",
+		"--filter",
+		"status=running"
+	]), {
+		...composeOptions(project),
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	});
+	return result.status === 0 ? result.stdout.split("\n").filter(Boolean) : [];
+}
+/**
+* The project a command acts on: the local production run when it is the
+* one running, otherwise the project `.env` describes.
+*/
+function activeProject(project) {
+	const localRun = readLocalRun(project);
+	if (!localRun) return project;
+	if (runningServices(project).length) return project;
+	return runningServices(localRun).length ? localRun : project;
+}
+// src/secrets.ts
+/** A URL-safe random secret with `bytes` bytes of randomness. */
+function generateSecret(bytes = 32) {
+	return randomBytes(bytes).toString("base64url");
+}
+/** The secrets a project's .env needs, by the name used in `{{secret:<name>}}`. */
+function generateProjectSecrets() {
+	return {
+		django: generateSecret(48),
+		postgres: generateSecret(24),
+		api: generateSecret(32),
+		api_read: generateSecret(32),
+		preview: generateSecret(32),
+		revalidate: generateSecret(32),
+		admin: generateSecret(12),
+		umami_app: generateSecret(32),
+		umami_admin: generateSecret(24)
+	};
+}
 // src/version.ts
 /** The version of this package, the same for every @django-stack package. */
 const CLI_VERSION = createRequire(import.meta.url)("../package.json").version;
+/** The npm package of the CLI. */
+const PACKAGE_NAME = "@django-stack/cli";
 // src/scaffold.ts
 /** The frontends this version of the CLI generates. */
 const FRONTENDS = stackOption("frontend").values.filter((value) => value.generated).map((value) => value.value);
@@ -992,6 +1234,7 @@ function scaffold(options) {
 	cpSync(join(templates, "backend"), join(target, "backend"), { recursive: true });
 	cpSync(frontendTemplate, join(target, "frontend"), { recursive: true });
 	renameSync(join(target, "gitignore"), join(target, ".gitignore"));
+	makeExecutable(target);
 	const about = join(target, "frontend", "template.json");
 	const frontend = JSON.parse(readFileSync(about, "utf8"));
 	rmSync(about);
@@ -1198,4 +1441,4 @@ function productionEnv(devEnv, options) {
 		todo
 	};
 }
-export { generateSecret as A, isDockerDown as B, applies as C, resolvePreset as D, pendingChoices as E, portValues as F, quoteEnvValue as H, runDoctor as I, checkTools as L, chooseFreePorts as M, describeMove as N, stackOption as O, envPorts as P, dockerNotRunning as R, STACK_OPTIONS as S, encodePreset as T, setEnvValues as U, parseEnv as V, validateTimeZone as _, LOCAL_S3 as a, NAMED_PRESETS as b, lockBackend as c, scaffold as d, timeZones as f, validateProjectName as g, usesValkey as h, FRONTENDS as i, DEV_PORTS as j, generateProjectSecrets as k, normalizeDatabaseUrl as l, umamiEnv as m, productionEnv as n, cacheEnv as o, toProjectName as p, validateDomain as r, localS3 as s, missingS3 as t, relativeDirectory as u, CLI_VERSION as v, decodePreset as w, PROMPT_ORDER as x, DEFAULT_STACK as y, dockerRunning as z };
+export { isDockerDown as $, projectUrls as A, encodePreset as B, RUN_ENV as C, findProjectDirectory as D, composeOutput as E, NAMED_PRESETS as F, chooseFreePorts as G, resolvePreset as H, PROMPT_ORDER as I, portValues as J, describeMove as K, STACK_OPTIONS as L, readProject as M, runningServices as N, parseProfiles as O, DEFAULT_STACK as P, dockerRunning as Q, applies as R, RUN_DOMAIN as S, compose as T, stackOption as U, pendingChoices as V, DEV_PORTS as W, checkTools as X, runDoctor as Y, dockerNotRunning as Z, validateTimeZone as _, LOCAL_S3 as a, generateProjectSecrets as b, lockBackend as c, scaffold as d, parseEnv as et, timeZones as f, validateProjectName as g, usesValkey as h, FRONTENDS as i, readLocalRun as j, projectStack as k, normalizeDatabaseUrl as l, umamiEnv as m, productionEnv as n, setEnvValues as nt, cacheEnv as o, toProjectName as p, envPorts as q, validateDomain as r, localS3 as s, missingS3 as t, quoteEnvValue as tt, relativeDirectory as u, CLI_VERSION as v, activeProject as w, generateSecret as x, PACKAGE_NAME as y, decodePreset as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@django-stack/cli",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "The production-ready Django, batteries included stack. Create and manage DjangoStack projects: a Django backend, a frontend, Postgres and Docker Compose in one command.",
   "license": "MIT",
   "author": "Leon van der Grient",

package/templates/backend/Dockerfile

@@ -25,10 +25,12 @@ RUN --mount=type=cache,target=/root/.cache/uv \
 
 # Development runs as root, so files the container writes into the mounted
 # source (such as new migrations) work on every host. Production does not.
+# The entrypoint runs with sh, so it works without the executable bit (the
+# mounted source keeps the host's file modes).
 FROM deps AS dev
 RUN --mount=type=cache,target=/root/.cache/uv \
     uv sync --no-install-project
-ENTRYPOINT ["/app/entrypoint.sh"]
+ENTRYPOINT ["sh", "/app/entrypoint.sh"]
 CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
 
 FROM base AS prod
@@ -41,5 +43,5 @@ USER app
 EXPOSE 8000
 HEALTHCHECK --interval=10s --timeout=5s --start-period=30s --retries=5 \
     CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/readyz', timeout=4)"
-ENTRYPOINT ["/app/entrypoint.sh"]
+ENTRYPOINT ["sh", "/app/entrypoint.sh"]
 CMD ["gunicorn", "config.asgi:application", "--worker-class", "uvicorn_worker.UvicornWorker", "--bind", "0.0.0.0:8000", "--workers", "3", "--access-logfile", "-", "--no-control-socket"]

package/templates/backend/pyproject.toml

@@ -5,7 +5,7 @@ description = "The Django backend of {{project_name}}."
 requires-python = ">=3.12"
 dependencies = [
     "Django>=6.1,<6.2",
-    "django-stack[server,s3]>=0.7.0",
+    "django-stack[server,s3]>=0.8.1",
     "django-headless[schema]>=1.1.1",
     "django-content-studio[images,huey]>=1.11.0",
 ]

package/templates/frontend-astro/Dockerfile

@@ -14,7 +14,10 @@ RUN --mount=type=cache,target=/root/.npm \
 
 FROM deps AS dev
 EXPOSE 3000
-CMD ["npm", "run", "dev"]
+# A container runs one dev server, so a lock file in the mounted .astro/ is
+# always stale: from a stopped container, whose process IDs the new one reuses,
+# or from `npm run dev` on the host. Astro would refuse to start next to it.
+CMD ["sh", "-c", "rm -f .astro/dev.json && exec npm run dev"]
 
 FROM deps AS build
 COPY . .

package/templates/frontend-astro/package.json

@@ -16,7 +16,7 @@
     "@astrojs/node": "^11.1.9",
     "@astrojs/rss": "^4.0.19",
     "@django-headless/client": "^1.1.1",
-    "@django-stack/utils": "^0.7.0",
+    "@django-stack/utils": "^0.8.1",
     "astro": "^7.4.5"
   },
   "devDependencies": {

package/templates/frontend-next/package.json

@@ -13,9 +13,9 @@
   },
   "dependencies": {
     "@django-headless/client": "^1.1.1",
-    "@django-stack/next": "^0.7.0",
-    "@django-stack/react": "^0.7.0",
-    "@django-stack/utils": "^0.7.0",
+    "@django-stack/next": "^0.8.1",
+    "@django-stack/react": "^0.8.1",
+    "@django-stack/utils": "^0.8.1",
     "next": "^16.4.4",
     "react": "^19.3.1",
     "react-dom": "^19.3.1",

package/templates/frontend-nuxt/package.json

@@ -15,8 +15,8 @@
   },
   "dependencies": {
     "@django-headless/client": "^1.1.1",
-    "@django-stack/utils": "^0.7.0",
-    "@django-stack/vue": "^0.7.0",
+    "@django-stack/utils": "^0.8.1",
+    "@django-stack/vue": "^0.8.1",
     "nuxt": "^4.6.3",
     "nuxt-security": "^2.7.0",
     "vue": "^3.5.44",

package/templates/frontend-sveltekit/package.json

@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@django-headless/client": "^1.1.1",
-    "@django-stack/svelte": "^0.7.0",
-    "@django-stack/utils": "^0.7.0"
+    "@django-stack/svelte": "^0.8.1",
+    "@django-stack/utils": "^0.8.1"
   },
   "devDependencies": {
     "@sveltejs/adapter-node": "^6.0.1",