@django-stack/cli 0.6.0 → 0.7.0

package/dist/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { C as stackOption, D as checkTools, E as runDoctor, O as parseEnv, S as resolvePreset, T as generateSecret, _ as STACK_OPTIONS, a as lockBackend, b as encodePreset, c as scaffold, d as umamiEnv, f as validateProjectName, g as NAMED_PRESETS, h as DEFAULT_STACK, i as LOCAL_S3, k as setEnvValues, l as timeZones, m as CLI_VERSION, n as validateDomain, p as validateTimeZone, s as relativeDirectory, t as productionEnv$1, u as toProjectName, v as applies, w as generateProjectSecrets, x as pendingChoices, y as decodePreset } from "./production-DIj9yRcg.js";
+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 { createRequire } from "node:module";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { basename, delimiter, dirname, join, resolve } from "node:path";
+import { basename, delimiter, dirname, join, relative, resolve } from "node:path";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import pc from "picocolors";
 import tab from "@bomb.sh/tab/commander";
@@ -136,7 +136,7 @@ function probeFor(definition, ports) {
 }
 /** Plans the Bunny app for a resolved Compose project. */
 function planApp(project, options) {
-	const entries = Object.entries(project.services).sort(([a], [b]) => a.localeCompare(b));
+	const entries = Object.entries(project.services).filter(([, definition]) => definition.deploy?.replicas !== 0).sort(([a], [b]) => a.localeCompare(b));
 	if (!entries.length) throw new Error("compose.yaml has no services for production.");
 	const names = /* @__PURE__ */ new Map();
 	for (const [service, definition] of entries) names.set(service, hostNames(service, definition));
@@ -1126,6 +1126,7 @@ var BunnyClient = class {
 	async docker(args, options = {}) {
 		const result = await this.run("docker", args, options);
 		if (result.code === 0) return result.stdout;
+		if (isDockerDown(`${result.stderr}\n${result.stdout}`)) throw new Error(dockerNotRunning());
 		const last = (result.stderr.trim() || result.stdout.trim()).split("\n").at(-1) ?? "";
 		throw new Error(`docker ${args[0]} failed (exit ${result.code})${last ? `: ${last}` : "."}`);
 	}
@@ -2573,20 +2574,41 @@ function projectManifest(project) {
 * generated have the default in their preset without running it.
 */
 function projectStack(project) {
-	const analytics = project.profiles.includes("analytics") ? "umami" : "off";
+	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),
-			analytics
+			...fromEnv
 		};
 	} catch {}
 	return {
 		...DEFAULT_STACK,
-		analytics,
+		...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) {
@@ -2599,23 +2621,25 @@ function projectUrls(project) {
 			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: "http://localhost:3000"
+			url: site
 		},
 		{
 			label: "Admin",
-			url: "http://localhost:3000/admin/"
+			url: `${site}/admin/`
 		},
 		{
 			label: "Mail",
-			url: "http://localhost:8025"
+			url: `http://localhost:${ports.MAIL_PORT}`
 		}
 	];
 	if (project.profiles.includes("s3")) urls.push({
 		label: "S3",
-		url: "http://localhost:8333"
+		url: `http://localhost:${ports.S3_PORT}`
 	});
 	return urls;
 }
@@ -3422,14 +3446,23 @@ async function offerGlobalInstall() {
 	return true;
 }
 // src/commands/init.ts
-/** The prompt choices of an option; values this version does not generate yet are shown but disabled. */
-function choices(key) {
-	return stackOption(key).values.map((value, index) => ({
-		value: value.value,
-		label: value.label,
-		hint: value.generated || index === 0 ? value.hint : "coming soon",
-		disabled: !value.generated && index > 0
-	}));
+/**
+* The prompt choices of an option; values this version does not generate yet
+* are shown but disabled. The tasks follow the cache chosen before them: Huey
+* keeps its queue in the database, or in Valkey with the Valkey cache.
+*/
+function choices(key, stack = {}) {
+	return stackOption(key).values.flatMap((value, index) => {
+		let hint = value.generated || index === 0 ? value.hint : "coming soon";
+		if (key === "tasks" && value.value === "huey") hint = stack.cache === "valkey" ? "a worker container, the queue in Valkey" : "a worker container, the queue in Postgres";
+		if (key === "tasks" && value.value === "huey-valkey" && stack.cache === "valkey") return [];
+		return [{
+			value: value.value,
+			label: value.label,
+			hint,
+			disabled: !value.generated && index > 0
+		}];
+	});
 }
 /**
 * The stack from, in order of precedence, the flags, the preset, the prompts
@@ -3445,8 +3478,8 @@ async function chooseStack(options, interactive, askDatabase) {
 	}
 	const stack = { ...DEFAULT_STACK };
 	let databaseUrl;
-	for (const option of STACK_OPTIONS) {
-		const key = option.key;
+	for (const key of PROMPT_ORDER) {
+		const option = stackOption(key);
 		if (options.fromCli(key)) stack[key] = options[key];
 		else if (key === "storage" && options.fromCli("localS3") && options.localS3) stack[key] = "s3";
 		else if (preset) stack[key] = preset[key];
@@ -3456,11 +3489,14 @@ async function chooseStack(options, interactive, askDatabase) {
 			if ("databaseUrl" in answer) databaseUrl = answer.databaseUrl;
 			else stack[key] = answer.postgres;
 		} else if (key === "postgres" && options.databaseUrl) continue;
-		else stack[key] = unwrap(await p.select({
-			message: option.message,
-			options: choices(key),
-			initialValue: stack[key]
-		}));
+		else {
+			const initialValue = key === "storage" && stack.media === "s3" ? "s3" : stack[key];
+			stack[key] = unwrap(await p.select({
+				message: option.message,
+				options: choices(key, stack),
+				initialValue
+			}));
+		}
 	}
 	return {
 		stack,
@@ -3555,6 +3591,8 @@ async function init(directoryArgument, options) {
 		message: "Add demo content? (example pages and posts)",
 		initialValue: true
 	}));
+	const ports = await chooseFreePorts({}, stack.storage === "s3" ? ["s3"] : []);
+	for (const move of ports.moves) p.log.info(describeMove(move));
 	const spinner = p.spinner();
 	spinner.start("Creating the project");
 	let result;
@@ -3567,8 +3605,11 @@ async function init(directoryArgument, options) {
 			databaseUrl,
 			localS3: stack.storage === "s3",
 			analytics: stack.analytics === "umami",
+			cache: stack.cache,
+			tasks: stack.tasks,
 			preset: encodePreset(stack),
 			timeZone,
+			ports: ports.ports,
 			link: options.link
 		});
 	} catch (error) {
@@ -3603,22 +3644,24 @@ async function init(directoryArgument, options) {
 	} catch {
 		p.log.warn("Could not commit the project with git. Commit it yourself.");
 	}
+	if (options.installPrompt !== false && !options.yes) await offerGlobalInstall();
+	const startCommand = isOnPath() ? "dstack dev" : "docker compose up";
 	p.note([
 		command(`cd ${relativeDirectory(target)}`),
-		command("docker compose up"),
+		command(startCommand),
 		"",
-		`${pc.bold("Site")}    ${url("http://localhost:3000")}`,
-		`${pc.bold("Admin")}   ${url("http://localhost:3000/admin/")}`,
-		`${pc.bold("Mail")}    ${url("http://localhost:8025")}`,
+		`${pc.bold("Site")}    ${url(`http://localhost:${ports.ports.SITE_PORT}`)}`,
+		`${pc.bold("Admin")}   ${url(`http://localhost:${ports.ports.SITE_PORT}/admin/`)}`,
+		`${pc.bold("Mail")}    ${url(`http://localhost:${ports.ports.MAIL_PORT}`)}`,
 		"",
 		`Admin user ${secret(result.adminUsername)}, password ${secret(result.adminPassword)}`,
 		pc.dim("The password is in .env as ADMIN_PASSWORD. Change it after you sign in.")
 	].join("\n"), "Next steps");
 	if (pending.length) p.log.info(`Coming in a later version, so not in this project yet: ${pending.map((item) => `${stackOption(item.key).message.toLowerCase()} (${stack[item.key]})`).join(", ")}.`);
+	if (stack.media === "s3") p.log.info(`Uploads go to S3 in production. Before the first deploy, ${command("dstack production")} asks for the S3 settings; ${command("dstack settings")} changes them later.`);
 	p.log.message(`Create the same stack with ${command(`--preset ${encodePreset(stack)}`)}`);
-	if (options.start && !dockerReady) p.outro(pc.yellow(`Docker is not ready, so the project was not started. Fix the warnings above and run ${command("docker compose up")}.`));
+	if (options.start && !dockerReady) p.outro(pc.yellow(`Docker is not ready, so the project was not started. Fix the warnings above and run ${command(startCommand)}.`));
 	else if (options.start) {
-		if (options.installPrompt !== false && !options.yes) await offerGlobalInstall();
 		p.outro(`Starting the project with ${command("docker compose up")}`);
 		execFileSync("docker", ["compose", "up"], {
 			cwd: target,
@@ -3637,8 +3680,9 @@ async function preset(code, options) {
 		} catch (error) {
 			fail(error.message);
 		}
-		const lines = STACK_OPTIONS.filter((option) => applies(option.key, stack)).map((option) => {
-			const value = option.values.find((candidate) => candidate.value === stack[option.key]);
+		const lines = PROMPT_ORDER.filter((key) => applies(key, stack)).map((key) => {
+			const option = stackOption(key);
+			const value = option.values.find((candidate) => candidate.value === stack[key]);
 			return `${pc.bold(option.message.padEnd(24))}${value?.label ?? ""}`;
 		});
 		p.note(lines.join("\n"), command(`--preset ${encodePreset(stack)}`));
@@ -3649,6 +3693,295 @@ async function preset(code, options) {
 	const encoded = encodePreset(stack);
 	p.outro(`Create this stack with ${command(`${selfCommand()} init --preset ${encoded}`)}`);
 }
+// src/settings.ts
+function validateEmail(value) {
+	return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) ? void 0 : "Enter an email address, such as you@example.com.";
+}
+function validateHost(value) {
+	return /^[a-z0-9.-]+$/i.test(value) && value.includes(".") ? void 0 : "Enter a host name, such as smtp.example.com.";
+}
+function validatePort(value) {
+	const port = Number(value);
+	return Number.isInteger(port) && port > 0 && port < 65536 ? void 0 : "Enter a port, such as 587.";
+}
+function validateUrl(value) {
+	if (!value) return void 0;
+	return /^https?:\/\/[^\s/]+/.test(value) ? void 0 : "Enter a URL that starts with https://.";
+}
+const required = (label) => (value) => value.trim() ? void 0 : `Enter the ${label}.`;
+/**
+* An SMTP URL for EMAIL_URL: smtps:// on port 465, smtp:// on 25, otherwise
+* smtp+tls:// (STARTTLS), with the user name and password URL-encoded.
+*/
+function smtpUrl(parts) {
+	const port = Number(parts.port || "587");
+	const scheme = port === 465 ? "smtps" : port === 25 ? "smtp" : "smtp+tls";
+	const user = parts.username ? encodeURIComponent(parts.username) : "";
+	const password = parts.password ? `:${encodeURIComponent(parts.password)}` : "";
+	return `${scheme}://${user ? `${user}${password}@` : ""}${parts.host}:${port}`;
+}
+/** The parts of an SMTP URL, for the current answers. */
+function smtpParts(value) {
+	try {
+		const url = new URL(value ?? "");
+		return {
+			host: url.hostname,
+			port: url.port,
+			username: decodeURIComponent(url.username),
+			password: decodeURIComponent(url.password)
+		};
+	} catch {
+		return {};
+	}
+}
+const placeholderMail = (value) => !value || value.includes("mailpit") || value.includes("example.com") || value.startsWith("console:");
+const SETTING_GROUPS = [
+	{
+		title: "Admin email",
+		names: ["ADMIN_EMAIL"],
+		applies: () => true,
+		missing: (env) => !env.ADMIN_EMAIL || env.ADMIN_EMAIL.endsWith("@example.com") ? ["ADMIN_EMAIL"] : [],
+		fields: [{
+			name: "ADMIN_EMAIL",
+			message: "Your email address, for the admin user",
+			placeholder: "you@example.com",
+			validate: validateEmail
+		}],
+		values: (answers) => ({ ADMIN_EMAIL: answers.ADMIN_EMAIL ?? "" })
+	},
+	{
+		title: "Outgoing mail",
+		names: ["EMAIL_URL"],
+		applies: () => true,
+		missing: (env) => placeholderMail(env.EMAIL_URL) ? ["EMAIL_URL"] : [],
+		fields: [
+			{
+				name: "host",
+				message: "SMTP server",
+				placeholder: "smtp.example.com",
+				validate: validateHost
+			},
+			{
+				name: "port",
+				message: "SMTP port",
+				defaultValue: "587",
+				validate: validatePort
+			},
+			{
+				name: "username",
+				message: "SMTP user name",
+				optional: true
+			},
+			{
+				name: "password",
+				message: "SMTP password",
+				secret: true,
+				optional: true
+			}
+		],
+		current: (env, field) => placeholderMail(env.EMAIL_URL) ? void 0 : smtpParts(env.EMAIL_URL)[field],
+		values: (answers) => ({ EMAIL_URL: smtpUrl({
+			host: answers.host ?? "",
+			port: answers.port ?? "587",
+			username: answers.username,
+			password: answers.password
+		}) })
+	},
+	{
+		title: "S3 for uploads",
+		names: [
+			"S3_BUCKET",
+			"S3_ENDPOINT_URL",
+			"S3_REGION",
+			"S3_ACCESS_KEY_ID",
+			"S3_SECRET_ACCESS_KEY",
+			"S3_PUBLIC_URL"
+		],
+		applies: (env, context) => context.media === "s3" || Boolean(env.S3_BUCKET),
+		missing: missingS3,
+		fields: [
+			{
+				name: "S3_BUCKET",
+				message: "S3 bucket",
+				placeholder: "example-media",
+				validate: required("bucket")
+			},
+			{
+				name: "S3_ENDPOINT_URL",
+				message: "S3 endpoint, empty for AWS",
+				placeholder: "https://fsn1.your-objectstorage.com",
+				optional: true,
+				validate: validateUrl
+			},
+			{
+				name: "S3_REGION",
+				message: "S3 region",
+				placeholder: "eu-central-1",
+				validate: required("region")
+			},
+			{
+				name: "S3_ACCESS_KEY_ID",
+				message: "S3 access key ID",
+				validate: required("access key ID")
+			},
+			{
+				name: "S3_SECRET_ACCESS_KEY",
+				message: "S3 secret access key",
+				secret: true,
+				validate: required("secret access key")
+			},
+			{
+				name: "S3_PUBLIC_URL",
+				message: "Public URL of the files, empty when it is the endpoint",
+				placeholder: "https://media.example.com",
+				optional: true,
+				validate: validateUrl
+			}
+		],
+		current: (env, field) => env[field],
+		values: (answers) => Object.fromEntries([
+			"S3_BUCKET",
+			"S3_ENDPOINT_URL",
+			"S3_REGION",
+			"S3_ACCESS_KEY_ID",
+			"S3_SECRET_ACCESS_KEY",
+			"S3_PUBLIC_URL"
+		].map((name) => [name, answers[name] ?? ""]))
+	}
+];
+/** The groups of a production `.env` to ask for: the missing ones, or with `all` every one that applies. */
+function settingsToAsk(env, context, all = false) {
+	return SETTING_GROUPS.filter((group) => group.applies(env, context) && (all || group.missing(env).length));
+}
+/** Every `.env` variable `--set` takes. */
+const SETTING_NAMES = SETTING_GROUPS.flatMap((group) => group.names);
+/** Parses `--set NAME=value` arguments. Throws with a one-line reason. */
+function parseAssignments(items) {
+	const values = {};
+	for (const item of items) {
+		const index = item.indexOf("=");
+		const name = index > 0 ? item.slice(0, index) : "";
+		if (!SETTING_NAMES.includes(name)) throw new Error(`${JSON.stringify(item)} is not NAME=value for one of ${SETTING_NAMES.join(", ")}.`);
+		const value = item.slice(index + 1);
+		if (/[\r\n]/.test(value)) throw new Error(`The value of ${name} has a line break.`);
+		if (name === "ADMIN_EMAIL" && validateEmail(value)) throw new Error(`ADMIN_EMAIL: ${validateEmail(value)}`);
+		values[name] = value;
+	}
+	return values;
+}
+/** The items of `production`'s to-do list that the settings now in `env` have done. */
+function remainingTodo(todo, env) {
+	return todo.filter((item) => {
+		const group = SETTING_GROUPS.find((candidate) => candidate.names.some((name) => item.includes(name.startsWith("S3_") ? "S3_" : name)));
+		return !group || group.missing(env).length > 0;
+	});
+}
+// src/commands/settings.ts
+/** The `media` stack option of the project, from the preset in package.json. */
+function projectContext(directory) {
+	try {
+		return { media: projectStack(readProject(directory)).media };
+	} catch {
+		return {};
+	}
+}
+/** Asks for each field of the groups; returns the `.env` values. */
+async function askSettings(groups, env) {
+	const values = {};
+	for (const group of groups) {
+		p.log.step(pc.bold(group.title));
+		const answers = {};
+		for (const field of group.fields) {
+			const current = group.current?.(env, field.name);
+			const check = (value) => {
+				const text = (value ?? "").trim();
+				if (!text && (field.optional || field.defaultValue || field.secret && current)) return void 0;
+				return field.validate?.(text) ?? (text ? void 0 : `Enter the ${field.message.toLowerCase()}.`);
+			};
+			let answer;
+			if (field.secret) {
+				answer = unwrap(await p.password({
+					message: current ? `${field.message} (empty keeps the current one)` : field.message,
+					validate: check
+				}));
+				if (!answer && current) answer = current;
+			} else answer = unwrap(await p.text({
+				message: field.message,
+				placeholder: field.placeholder ?? field.defaultValue,
+				initialValue: current,
+				defaultValue: field.defaultValue,
+				validate: check
+			}));
+			answers[field.name] = (answer ?? field.defaultValue ?? "").trim();
+		}
+		Object.assign(values, group.values(answers));
+	}
+	return values;
+}
+/** Writes values to a `.env` file, quoted where Compose needs it. Throws for a value it can't write. */
+function writeSettings(path, values) {
+	const quoted = Object.fromEntries(Object.entries(values).map(([name, value]) => [name, quoteEnvValue(value)]));
+	writeFileSync(path, setEnvValues(readFileSync(path, "utf8"), quoted), { mode: 384 });
+}
+/** The production `.env` of a project: `--file`, `.env.production`, or `.env` on a server. */
+function targetFile(directory, file) {
+	if (file) {
+		const path = join(directory, file);
+		if (!existsSync(path)) fail(`${path} does not exist.`);
+		return path;
+	}
+	const production = join(directory, ".env.production");
+	if (existsSync(production)) return production;
+	const env = join(directory, ".env");
+	if (existsSync(env) && parseProfiles(parseEnv(readFileSync(env, "utf8")).COMPOSE_PROFILES).includes("prod")) return env;
+	fail(`There is no .env.production yet. Write it with ${command("dstack production")}.`);
+}
+/** `dstack settings`: ask for the missing production settings and credentials, and save them. */
+async function settings(options) {
+	const interactive = isInteractive(options.yes);
+	intro("Production settings");
+	const directory = findProjectDirectory(options.dir ?? ".");
+	if (!directory) fail("No DjangoStack project here: run this where compose.yaml and .env are.");
+	const target = targetFile(directory, options.file);
+	const name = relative(directory, target);
+	let assigned;
+	try {
+		assigned = parseAssignments(options.set ?? []);
+	} catch (error) {
+		fail(error.message);
+	}
+	const env = {
+		...parseEnv(readFileSync(target, "utf8")),
+		...assigned
+	};
+	const context = projectContext(directory);
+	const missing = settingsToAsk(env, context);
+	let values = assigned;
+	if (interactive) {
+		const groups = settingsToAsk(env, context, options.all);
+		if (!groups.length && !Object.keys(assigned).length) {
+			p.outro(pc.green(`Nothing is missing in ${name}`));
+			return;
+		}
+		if (groups.length && !options.all) p.log.info(`${name} needs ${groups.map((group) => group.title.toLowerCase()).join(", ")}.`);
+		values = {
+			...assigned,
+			...await askSettings(groups, env)
+		};
+	} else if (missing.length) fail(`${name} misses ${missing.flatMap((group) => group.missing(env)).join(", ")}. Pass them with --set NAME=value.`);
+	else if (!Object.keys(assigned).length) {
+		p.outro(pc.green(`Nothing is missing in ${name}`));
+		return;
+	}
+	try {
+		writeSettings(target, values);
+	} catch (error) {
+		fail(error.message);
+	}
+	p.log.success(`Saved ${Object.keys(values).join(", ")} in ${pc.bold(name)}`);
+	if (existsSync(join(directory, ".dstack", "deploy.json")) && target.endsWith(".env.production")) p.outro(`Send them to the platform with ${command("dstack deploy env push")}`);
+	else p.outro(pc.green("Done"));
+}
 // src/commands/production.ts
 async function production(directoryArgument, options) {
 	const interactive = isInteractive(options.yes);
@@ -3667,18 +4000,36 @@ async function production(directoryArgument, options) {
 			validate: (v) => validateDomain(v ?? "")
 		}));
 	}
+	const context = projectContext(directory);
 	let result;
 	try {
 		result = productionEnv$1(readFileSync(envPath, "utf8"), {
 			domain,
-			emailUrl: options.emailUrl
+			emailUrl: options.emailUrl,
+			media: context.media
 		});
 	} catch (error) {
 		fail(error.message);
 	}
 	writeFileSync(target, result.text, { mode: 384 });
 	p.log.success(`Wrote ${pc.bold(relativeDirectory(target))} with new secrets for the server.`);
-	if (result.todo.length) p.note(result.todo.map((item) => `${pc.yellow("•")} ${item}`).join("\n"), "Before the first deploy");
+	let todo = result.todo;
+	const missing = settingsToAsk(parseEnv(result.text), context);
+	if (interactive && missing.length) {
+		if (unwrap(await p.confirm({
+			message: `Set the ${missing.map((group) => group.title.toLowerCase()).join(", ")} now?`,
+			initialValue: true
+		}))) {
+			try {
+				writeSettings(target, await askSettings(missing, parseEnv(result.text)));
+			} catch (error) {
+				fail(error.message);
+			}
+			todo = remainingTodo(todo, parseEnv(readFileSync(target, "utf8")));
+		}
+	}
+	if (todo.some((item) => SETTING_NAMES.some((name) => item.includes(name.startsWith("S3_") ? "S3_" : name)))) todo = [...todo, `Run ${command("dstack settings")} to set them.`];
+	if (todo.length) p.note(todo.map((item) => `${pc.yellow("•")} ${item}`).join("\n"), "Before the first deploy");
 	p.note([
 		`Copy the project to the server, with ${pc.bold(".env.production")} as ${pc.bold(".env")}, then:`,
 		command("docker compose up -d --build"),
@@ -3690,7 +4041,13 @@ async function production(directoryArgument, options) {
 }
 // src/config.ts
 /** The options `config` can switch in an existing project. The rest follow with code generation. */
-const SWITCHABLE = ["storage", "analytics"];
+const SWITCHABLE = [
+	"storage",
+	"analytics",
+	"media",
+	"cache",
+	"tasks"
+];
 const EMPTY_S3 = Object.fromEntries(Object.keys(LOCAL_S3).map((key) => [key, key === "S3_CREATE_BUCKET" ? "0" : ""]));
 /**
 * Applies a new stack to a project's `.env`. Throws with a one-line reason
@@ -3713,11 +4070,30 @@ function applyStack(envText, env, from, to) {
 			profiles = profiles.filter((profile) => profile !== "s3");
 			if (to.storage === "s3") profiles.push("s3");
 			text = setEnvValues(text, {
-				...to.storage === "s3" ? LOCAL_S3 : EMPTY_S3,
+				...to.storage === "s3" ? localS3(envPorts(env).S3_PORT) : EMPTY_S3,
 				COMPOSE_PROFILES: profiles.join(",")
 			});
 			changes.push(to.storage === "s3" ? "Uploads go to the local S3 service (the s3 profile)." : "Uploads go to a Docker volume; the local S3 service is off.");
 		}
+		if (key === "cache") {
+			text = setEnvValues(text, { CACHE_URL: cacheEnv(to).CACHE_URL ?? "" });
+			changes.push({
+				database: "The cache is a table in the database.",
+				valkey: "The cache is in Valkey (the valkey profile).",
+				off: "The cache is per process; nothing is shared."
+			}[to.cache]);
+		}
+		if (key === "tasks" || key === "cache" && from.tasks === "huey" && to.tasks === "huey") {
+			const { CACHE_URL: _, ...tasks } = cacheEnv(to);
+			const before = parseEnv(text).TASKS_URL;
+			text = setEnvValues(text, tasks);
+			if (before !== tasks.TASKS_URL) changes.push(to.tasks === "off" ? "Tasks run in the request; the worker is off, so there are no daily backups." : `The worker keeps its task queue in ${tasks.TASKS_URL === "db://" ? "the database" : "Valkey"}.`);
+		}
+		if (key === "cache" || key === "tasks") {
+			profiles = profiles.filter((profile) => profile !== "valkey");
+			if (usesValkey(parseEnv(text))) profiles.push("valkey");
+			text = setEnvValues(text, { COMPOSE_PROFILES: profiles.join(",") });
+		}
 		if (key === "analytics") {
 			profiles = profiles.filter((profile) => profile !== "analytics");
 			if (to.analytics === "umami") {
@@ -3737,6 +4113,7 @@ function applyStack(envText, env, from, to) {
 				changes.push("Page analytics are off; Umami's data stays in the database.");
 			}
 		}
+		if (key === "media") changes.push(to.media === "s3" ? "Uploads in production go to S3; dstack settings asks for the S3 settings." : "Uploads in production stay on the server.");
 	}
 	return {
 		env: text,
@@ -3755,6 +4132,7 @@ function setManifestPreset(manifestText, preset) {
 // src/commands/project.ts
 function open(options) {
 	if (!has("docker", ["compose", "version"])) fail("Docker Compose v2 was not found. Install Docker: https://docs.docker.com/get-docker/");
+	if (!dockerRunning()) fail(dockerNotRunning());
 	try {
 		return readProject(options.dir ?? ".");
 	} catch (error) {
@@ -3805,11 +4183,33 @@ async function run(options) {
 	if (project.localRun) p.log.message(pc.dim(`Caddy signs ${RUN_DOMAIN} with its own local CA, so the browser warns once. The admin password is in ${RUN_ENV}.`));
 	p.outro(`Stop it with ${command("dstack stop")}, follow the logs with ${command("dstack logs")}`);
 }
+/**
+* Moves the development services to free ports when theirs are in use, in
+* `.env`, unless the project already runs. compose.yaml from before the
+* *_PORT variables has fixed ports, so it can only say which one is in use.
+*/
+async function freeDevPorts(project) {
+	if (runningServices(project).length) return project;
+	const { ports, moves, stuck } = await chooseFreePorts(project.env, project.profiles);
+	const [blocked] = stuck;
+	if (blocked) fail(`Port ${envPorts(project.env)[blocked.name]} of the ${blocked.label} is in use. Stop what uses it.`);
+	if (!moves.length) return project;
+	const composeText = readFileSync(join(project.directory, "compose.yaml"), "utf8");
+	for (const move of moves) {
+		const item = DEV_PORTS.find((candidate) => candidate.label === move.label);
+		if (item && !composeText.includes(`\${${item.name}`)) fail(`Port ${move.from} of the ${move.label} is in use. Stop what uses it, or publish another port in compose.yaml.`);
+	}
+	const envPath = join(project.directory, ".env");
+	writeFileSync(envPath, setEnvValues(readFileSync(envPath, "utf8"), portValues(project.env, ports)), { mode: 384 });
+	for (const move of moves) p.log.info(`${describeMove(move)} Saved in .env.`);
+	return readProject(project.directory);
+}
 /** `dstack dev`: the dev profile in the foreground, with hot reload. */
 async function dev(options) {
-	const project = open(options);
+	let project = open(options);
 	if (project.prod) fail(`This .env runs the prod profile. Use ${command("dstack run")}.`);
 	intro("Develop");
+	project = await freeDevPorts(project);
 	urlsNote(project, "Starting");
 	p.log.message(pc.dim("Changes in backend/ and frontend/ reload. Press Ctrl+C to stop."));
 	exitWith(compose(project, ["up", ...options.build ? ["--build"] : []]));
@@ -3857,23 +4257,34 @@ async function shell(options) {
 	return manage(["shell"], options);
 }
 /**
-* The project and the service that run the backups: the prod worker, on a
+* The project and how to run a backup command: in the prod worker, on a
 * server or the local run, or the `backup` service of projects from 0.1.
+* Without a running worker (tasks off, TASK_WORKERS=0) in a one-off worker
+* container, while the backend runs.
 */
 function backupProject(options) {
 	const project = activeProject(open(options));
 	if (!project.prod) fail(`Backups run in the prod profile: on the server, or locally after ${command("dstack run")}.`);
 	const running = runningServices(project);
 	const service = ["backup", project.services.worker].find((name) => running.includes(name));
-	if (!service) fail(`The ${project.services.worker} service is not running. Start the project with ${command("dstack run")}.`);
-	return {
+	if (service) return {
 		project,
-		service
+		run: ["exec", service]
 	};
+	if (project.env.TASK_WORKERS === "0" && running.includes(project.services.backend)) return {
+		project,
+		run: [
+			"run",
+			"--rm",
+			"--no-deps",
+			project.services.worker
+		]
+	};
+	fail(`The ${project.services.worker} service is not running. Start the project with ${command("dstack run")}.`);
 }
 /** `dstack backup`: back up the database and the media now, or list the backups. */
 async function backup(options) {
-	const { project, service } = backupProject(options);
+	const { project, run } = backupProject(options);
 	const args = [
 		"python",
 		"manage.py",
@@ -3882,9 +4293,9 @@ async function backup(options) {
 	if (options.list) args.push("--list");
 	else if (!options.media) args.push("--no-media");
 	exitWith(compose(project, [
-		"exec",
+		run[0],
 		"-T",
-		service,
+		...run.slice(1),
 		...args
 	]));
 }
@@ -3909,13 +4320,13 @@ function restoreArgs(name, options) {
 }
 /** `dstack restore <backup>`: restore a database dump, with --media its media too, or a media archive. */
 async function restore(name, options) {
-	const { project, service } = backupProject(options);
+	const { project, run } = backupProject(options);
 	const args = restoreArgs(name, options);
 	if (!options.yes && !tty()) fail("Pass --yes to restore without a terminal.");
 	exitWith(compose(project, [
-		"exec",
+		run[0],
 		...options.yes ? ["-T"] : [],
-		service,
+		...run.slice(1),
 		...args
 	]));
 }
@@ -4153,20 +4564,12 @@ async function config(options) {
 	intro("Configure");
 	const current = projectStack(project);
 	const next = { ...current };
-	for (const option of STACK_OPTIONS) {
-		const key = option.key;
-		if (options.fromCli(key)) next[key] = options[key];
-		else if (interactive && SWITCHABLE.includes(key)) next[key] = unwrap(await p.select({
-			message: option.message,
-			initialValue: current[key],
-			options: option.values.map((value) => ({
-				value: value.value,
-				label: value.label,
-				hint: value.generated ? value.hint : "coming soon",
-				disabled: !value.generated && value.value !== current[key]
-			}))
-		}));
-	}
+	for (const key of PROMPT_ORDER) if (options.fromCli(key)) next[key] = options[key];
+	else if (interactive && SWITCHABLE.includes(key)) next[key] = unwrap(await p.select({
+		message: stackOption(key).message,
+		initialValue: current[key],
+		options: choices(key, next)
+	}));
 	if (next.analytics === "umami" && current.analytics !== "umami") {
 		const compose = join(project.directory, "compose.yaml");
 		if (!existsSync(compose) || !/^ {2}umami:/m.test(readFileSync(compose, "utf8"))) fail("compose.yaml has no umami service. Add it as the analytics docs describe, then run this again.");
@@ -4182,11 +4585,13 @@ async function config(options) {
 		p.outro("Nothing changed");
 		return;
 	}
-	writeFileSync(envPath, result.env, { mode: 384 });
+	const envText = readFileSync(envPath, "utf8");
+	if (result.env !== envText) writeFileSync(envPath, result.env, { mode: 384 });
 	const manifestPath = join(project.directory, "package.json");
 	if (existsSync(manifestPath)) writeFileSync(manifestPath, setManifestPreset(readFileSync(manifestPath, "utf8"), encodePreset(next)));
 	for (const change of result.changes) p.log.success(change);
-	p.outro(`Restart to apply it: ${command("dstack stop")}, then ${command("dstack dev")}`);
+	if (result.env === envText) p.outro(pc.green("Done"));
+	else p.outro(`Restart to apply it: ${command("dstack stop")}, then ${command("dstack dev")}`);
 }
 // src/program.ts
 /** Commands that print machine-readable output, so no update notice. */
@@ -4263,6 +4668,7 @@ function createProgram() {
 	}));
 	for (const flag of stackFlags()) presetCommand.addOption(flag);
 	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("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" });