@grayspar/cli 0.0.1 → 0.0.2

package/dist/commands/deploy/deploy.js

@@ -1,207 +1,161 @@
-/* Upload, then send the deploy and ask what the API returns, one question per round so a refused answer is asked
-   again at once: which service answers the address, and a path for each new one. */
-import { basename, resolve } from 'node:path';
+/* Upload the project, send the deploy and follow it until it is live or has failed. */
+import { openAsBlob, rmSync } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { Command, Option } from 'commander';
 import { dataOrThrow, signedInClient } from '../../lib/client.js';
 import { collectRepeatedValue, commandAction } from '../../lib/command-helpers.js';
 import { CliError } from '../../lib/errors.js';
-import { awaitDeployment, reportFailure } from '../../lib/follow-deployment.js';
-import { portLines } from '../../lib/listening.js';
-import { printNote, startProgress } from '../../lib/output.js';
-import { findLink, writeLink } from '../../lib/project-link.js';
-import { askChoice, askText, isInteractive } from '../../lib/prompt.js';
-import { projectIsNamed, resolveProject, teamProjects } from '../../lib/resolve-project.js';
-import { resolveTeam } from '../../lib/resolve-team.js';
+import { awaitDeployment, printDeployFailure, printReplacedDeploy, } from '../../lib/follow-deployment.js';
+import { startProgress } from '../../lib/output.js';
+import { writeLink } from '../../lib/project-link.js';
+import { CTRL_C_EXIT_CODE } from '../../lib/prompt.js';
+import { commandFor } from '../../lib/resolve-project.js';
 import { servicesTable } from '../../lib/services-table.js';
-import { color, failure, receipt, table, warning } from '../../lib/ui.js';
+import { color, receipt, table, warning } from '../../lib/ui.js';
 import { archiveOf } from './archive.js';
-import { parseDeployFlags, servicesToSend, } from './deploy-flags.js';
+import { awaitDiscovery } from './await-discovery.js';
+import { destinationFor } from './deploy-destination.js';
+import { NO_PATH_VALUE, parseDeployFlags, servicesToSend, } from './deploy-flags.js';
+import { deployTarget } from './deploy-target.js';
 import { emptyFoundVariables, variablesFor } from './env-files.js';
 import { gitStateOf } from './git-state.js';
-import { projectNameFrom } from './project-name.js';
+import { submitDeploy } from './submit-deploy.js';
 import { variablesToSend } from './variables-to-send.js';
+const UPLOAD_TIMEOUT_MS = 30 * 60 * 1000;
 async function deploy(folder, options) {
-    const root = resolve(folder);
+    const { link, root, under } = await deployTarget(process.cwd(), folder);
     const serviceFlags = parseDeployFlags(options.flags);
     const api = await signedInClient();
-    const destination = await destinationFor(api, root, options);
+    const destination = await destinationFor(api, root, link, options);
     const inspecting = startProgress(options.format, 'Inspecting your project…');
-    const uploaded = await uploadSource(api, destination, new Blob([await archiveOf(root)])).finally(inspecting.stop);
+    const uploaded = await uploadSource(api, destination, { root, under }, inspecting).finally(inspecting.stop);
     const variables = new Map(await Promise.all(uploaded.services.map(async (service) => [
         service.name,
         options.env
-            ? await variablesFor(root, service.rootDirectory, uploaded.platformVariables, options.envFile)
+            ? await variablesFor(root, service.rootFolder, uploaded.platformVariables, options.envFile)
             : emptyFoundVariables(),
     ])));
     if (options.format === 'text')
-        printFoundServices(uploaded, variables);
+        printFoundServices(uploaded, variables, under === '.');
     const foundNames = uploaded.services.map((service) => service.name);
     const deploying = servicesToSend(foundNames, serviceFlags).flatMap(({ name }) => {
         const known = variables.get(name);
         return known === undefined ? [] : [{ name, foundVariables: known }];
     });
-    const toSend = destination.kind === 'project'
-        ? await variablesToSend(api, destination.project, root, deploying.map((service) => service.name), deploying.map((service) => service.foundVariables), options.preference)
-        : Object.fromEntries(deploying.map((service) => [service.name, service.foundVariables.values]));
-    const gitState = await gitStateOf(root);
-    const { project, deployment } = await submitDeploy(api, destination, options, serviceFlags, foundNames, {
-        upload: uploaded.upload,
-        variables: toSend,
-        ...(gitState === null ? {} : { git: gitState }),
+    const chosen = await variablesToSend(api, destination.kind === 'project' ? destination.project : null, root, deploying.map((service) => service.name), deploying.map((service) => service.foundVariables), options.envConflict, {
+        projectName: destination.kind === 'project' ? destination.project.name : destination.name,
+        format: options.format,
+        yes: options.yes,
     });
-    if (destination.kind === 'new' || !destination.isLinked) {
+    const { project, deployment } = await submitDeploy(api, destination, options, serviceFlags, foundNames, { upload: uploaded.upload, variables: chosen.variables });
+    if (destination.kind === 'new' || destination.linksFolder) {
         await writeLink(root, { projectId: project.id });
     }
     if (options.format === 'text') {
-        for (const build of deployment.builds) {
-            for (const path of build.addedVolumes) {
-                process.stdout.write(`${receipt(`Added volume ${path} to ${build.service}`)}\n`);
-            }
+        for (const { service, addedVolume } of deployment.services) {
+            if (addedVolume === null)
+                continue;
+            process.stdout.write(`${receipt(`Added volume ${addedVolume} to ${service}`)}\n`);
         }
     }
     const outcome = await watchDeployment(api, project, deployment.id, options.format);
     if (options.format === 'json') {
-        process.stdout.write(`${JSON.stringify({ project: project.name, url: project.url, ...outcome }, null, 2)}\n`);
-        if (outcome.status === 'failed')
+        const variables = {
+            sent: Object.entries(chosen.variables).flatMap(([service, values]) => Object.keys(values).map((key) => ({ service, key }))),
+            leftOut: chosen.leftOut.map(({ service, key }) => ({ service, key })),
+        };
+        process.stdout.write(`${JSON.stringify({ project: project.name, url: project.url, variables, ...outcome }, null, 2)}\n`);
+        if (outcome.status !== 'live')
             process.exitCode = 1;
         return;
     }
-    await printOutcome(api, project, outcome, { uploaded, serviceFlags });
-}
-function uploadSource(api, destination, source) {
-    const body = { source };
-    const bodySerializer = (sent) => {
-        const form = new FormData();
-        form.append('source', sent.source, 'source.tar.gz');
-        return form;
+    await printOutcome(api, project, outcome);
+}
+async function uploadLimitsOf(api, destination) {
+    if (destination.kind === 'new')
+        return destination.team.uploadLimits;
+    const teams = await dataOrThrow(api.GET('/api/teams'));
+    const team = teams.find((candidate) => candidate.id === destination.project.teamId);
+    if (team === undefined)
+        throw new Error(`team ${destination.project.teamId} is not in /api/teams`);
+    return team.uploadLimits;
+}
+async function uploadSource(api, destination, source, progress) {
+    const scratch = await mkdtemp(join(tmpdir(), 'grayspar-'));
+    const removeScratchAndExit = () => {
+        rmSync(scratch, { recursive: true, force: true });
+        process.exit(CTRL_C_EXIT_CODE);
     };
-    return dataOrThrow(destination.kind === 'project'
-        ? api.POST('/api/projects/{id}/uploads', {
-            params: { path: { id: destination.project.id } },
-            body,
-            bodySerializer,
-        })
-        : api.POST('/api/teams/{teamId}/uploads', {
-            params: { path: { teamId: destination.team.id } },
-            body,
-            bodySerializer,
-        }));
-}
-const PATH_POINTER_PATTERN = /^#\/services\/(\d+)\/pathPrefix$/;
-function askedIn(refusal, sent) {
-    if (refusal === undefined)
-        return null;
-    if (refusal.questions !== undefined)
-        return { asked: refusal.questions, detail: refusal.detail };
-    const paths = (refusal.errors ?? []).flatMap(({ detail, pointer }) => {
-        const index = PATH_POINTER_PATTERN.exec(pointer ?? '')?.[1];
-        const service = index === undefined ? undefined : sent[Number(index)]?.name;
-        return service === undefined ? [] : [{ service, suggestion: null, problem: detail }];
-    });
-    return paths.length === 0 ? null : { asked: { address: [], paths }, detail: refusal.detail };
-}
-async function sendDeploy(api, destination, body) {
-    if (destination.kind === 'project') {
-        const answer = await api.POST('/api/projects/{id}/deployments', {
-            params: { path: { id: destination.project.id } },
-            body,
-        });
-        const asked = askedIn(answer.error, body.services ?? []);
-        if (asked !== null)
-            return asked;
-        const { deployment } = await dataOrThrow(Promise.resolve(answer));
-        return { accepted: { project: destination.project, deployment } };
-    }
-    const answer = await api.POST('/api/teams/{teamId}/projects', {
-        params: { path: { teamId: destination.team.id } },
-        body: { ...body, name: destination.name },
-    });
-    const asked = askedIn(answer.error, body.services ?? []);
-    if (asked !== null)
-        return asked;
-    return { accepted: await dataOrThrow(Promise.resolve(answer)) };
-}
-function refusalFor({ asked, detail }, suggestionsTaken) {
-    const action = asked.address.length > 0
-        ? 'Choose it with --path <name>=/.'
-        : suggestionsTaken
-            ? 'Give the path with --path <name>=<path>.'
-            : 'Give each path with --path <name>=<path>, or take the suggested paths with --yes.';
-    return new CliError('needs_a_path', `${detail}\n${action}`, '--path');
-}
-function suggestionsFor(askedQuestions) {
-    const taken = new Map();
-    for (const { service, suggestion, problem } of askedQuestions.asked.paths) {
-        if (suggestion === null || problem !== null)
-            throw refusalFor(askedQuestions, true);
-        taken.set(service, suggestion);
-    }
-    if (askedQuestions.asked.address.length > 0)
-        throw refusalFor(askedQuestions, true);
-    return taken;
-}
-async function askFirstQuestion(asked, address) {
-    if (asked.address.length > 0) {
-        const root = await askChoice(`Select the service that opens at ${address}`, `Opens at ${address}`, asked.address.map((name) => ({ value: name, label: name })), '--path');
-        return [root, '/'];
-    }
-    const [question] = asked.paths;
-    if (question === undefined)
-        throw new Error('The API asked a question without naming one.');
-    if (question.problem !== null)
-        process.stdout.write(`${failure(question.problem)}\n`);
-    return [
-        question.service,
-        await askText(`Path for ${question.service}`, question.suggestion, '--path'),
-    ];
-}
-async function submitDeploy(api, destination, options, serviceFlags, foundNames, request) {
-    const canAsk = options.format === 'text' && isInteractive() && !options.yes;
-    let hasAsked = false;
-    for (;;) {
-        const sent = await sendDeploy(api, destination, {
-            ...request,
-            services: servicesToSend(foundNames, serviceFlags),
-        });
-        if ('accepted' in sent) {
-            if (hasAsked)
-                process.stdout.write('\n');
-            return sent.accepted;
+    process.once('SIGINT', removeScratchAndExit);
+    try {
+        const archive = await archiveOf(source.root, source.under, scratch, await uploadLimitsOf(api, destination));
+        const gitState = await gitStateOf(join(source.root, source.under));
+        const body = {
+            bytes: archive.bytes,
+            sha256: archive.sha256,
+            ...(gitState === null ? {} : { gitMetadata: gitState }),
+        };
+        const created = await dataOrThrow(destination.kind === 'project'
+            ? api.POST('/api/projects/{projectId}/uploads', {
+                params: { path: { projectId: destination.project.id } },
+                body,
+            })
+            : api.POST('/api/teams/{teamId}/uploads', {
+                params: { path: { teamId: destination.team.id } },
+                body,
+            }));
+        progress.update('Uploading…');
+        const stored = await fetch(created.url, {
+            method: 'PUT',
+            body: await openAsBlob(archive.path),
+            headers: created.headers,
+            signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS),
+        }).catch(() => null);
+        if (stored?.ok !== true) {
+            throw new CliError('upload_failed', "Your project didn't finish uploading. Deploy again.");
         }
-        if (!options.yes && !canAsk)
-            throw refusalFor(sent, false);
-        const given = options.yes
-            ? suggestionsFor(sent)
-            : new Map([await askFirstQuestion(sent.asked, addressOf(destination))]);
-        hasAsked ||= !options.yes;
-        for (const [name, path] of given)
-            serviceFlags.paths.set(name, path);
+        progress.update('Inspecting your project…');
+        await dataOrThrow(destination.kind === 'project'
+            ? api.POST('/api/projects/{projectId}/uploads/{uploadId}/discover', {
+                params: { path: { projectId: destination.project.id, uploadId: created.upload } },
+            })
+            : api.POST('/api/teams/{teamId}/uploads/{uploadId}/discover', {
+                params: { path: { teamId: destination.team.id, uploadId: created.upload } },
+            }));
+        return await awaitDiscovery(api, destination, created.upload);
+    }
+    finally {
+        process.off('SIGINT', removeScratchAndExit);
+        await rm(scratch, { recursive: true, force: true });
     }
 }
-function addressOf(destination) {
-    return destination.kind === 'project'
-        ? new URL(destination.project.url).host
-        : "the project's address";
-}
-function printFoundServices(uploaded, variables) {
+function printFoundServices(uploaded, variables, isWholeProject) {
     const count = uploaded.services.length;
     const rows = uploaded.services.map((service) => [service.name, service.builtWith ?? '…']);
-    process.stdout.write(`${color.heading(`Found ${String(count)} ${count === 1 ? 'service' : 'services'}`)}\n\n` +
-        `${table(['SERVICE', 'BUILT WITH'], rows)}\n`);
+    const found = count === 0
+        ? []
+        : [
+            `${color.heading(`Found ${String(count)} ${count === 1 ? 'service' : 'services'}`)}\n\n` +
+                table(['SERVICE', 'BUILT WITH'], rows),
+        ];
     const leftOut = new Set([...variables.values()].flatMap((service) => Object.entries(service.skippedPlatformVariables).map(([key, file]) => `${key} in ${file} is left out, because Grayspar sets it`)));
     const warnings = [
         ...leftOut,
-        ...uploaded.services.flatMap((service) => (variables.get(service.name)?.expectedButMissing ?? []).map((key) => `${service.name} expects ${key}, which has no value`)),
-        ...uploaded.leftRunning.map((name) => `${name} is no longer in this folder, and keeps running`),
+        ...(isWholeProject
+            ? uploaded.leftRunning.map((name) => `${name} is no longer in this folder, and keeps running`)
+            : []),
     ];
-    if (warnings.length > 0)
-        process.stdout.write(`\n${warnings.map(warning).join('\n')}\n`);
-    process.stdout.write('\n');
+    const blocks = [...found, ...(warnings.length > 0 ? [warnings.map(warning).join('\n')] : [])];
+    if (blocks.length > 0)
+        process.stdout.write(`${blocks.join('\n\n')}\n\n`);
 }
 async function watchDeployment(api, project, deploymentId, format) {
+    const follow = await commandFor(project, 'grayspar status');
     const stopWatching = () => {
-        process.stderr.write(`\nThe deploy goes on without this terminal. To follow it, run\ngrayspar status --project ${project.name}\n`);
-        process.exit(130);
+        process.stderr.write(`\nThe deploy goes on without this terminal. To follow it, run\n${follow}\n`);
+        process.exit(CTRL_C_EXIT_CODE);
     };
     process.once('SIGINT', stopWatching);
     try {
@@ -211,132 +165,20 @@ async function watchDeployment(api, project, deploymentId, format) {
         process.off('SIGINT', stopWatching);
     }
 }
-async function printOutcome(api, project, outcome, { uploaded, serviceFlags }) {
+async function printOutcome(api, project, outcome) {
     if (outcome.status === 'live') {
-        const live = await dataOrThrow(api.GET('/api/projects/{id}', { params: { path: { id: project.id } } }));
-        const ports = portLines(outcome.listening);
-        process.stdout.write(`${[receipt(`Deployed ${live.name}`), ...ports.receipts].join('\n')}\n\n${servicesTable(live)}\n` +
-            (ports.warnings.length === 0 ? '' : `\n${ports.warnings.join('\n')}\n`));
+        const live = await dataOrThrow(api.GET('/api/projects/{projectId}', { params: { path: { projectId: project.id } } }));
+        process.stdout.write(`${receipt(`Deployed ${live.name}`)}\n\n${servicesTable(live)}\n`);
         return;
     }
-    if (outcome.status === 'pending') {
-        process.stdout.write(`Still building. To follow it, run\ngrayspar logs --build --project ${project.name}\n`);
+    if (outcome.status === 'cancelled') {
+        await printReplacedDeploy(project);
         return;
     }
-    await reportFailure(api, project, outcome, dockerfileHint(uploaded, outcome, serviceFlags));
-}
-function dockerfileHint(uploaded, outcome, serviceFlags) {
-    const service = uploaded.services.find((candidate) => candidate.name === outcome.failedService);
-    if (outcome.built ||
-        service === undefined ||
-        service.builder !== 'dockerfile' ||
-        service.dockerfile !== null ||
-        serviceFlags.dockerfiles.has(service.name) ||
-        service.rootDirectory === '.') {
-        return undefined;
-    }
-    const path = `${service.rootDirectory}/Dockerfile`;
-    return [
-        `If ${path} builds from the project's root, run`,
-        `grayspar service set ${service.name} --dockerfile ${path}`,
-        'and deploy again.',
-    ];
-}
-export function destinationOptions(projects, suggestedName) {
-    const match = projects.find((project) => project.name === suggestedName);
-    const others = projects
-        .filter((project) => project !== match)
-        .map((project) => ({ kind: 'existing', project }));
-    const create = { kind: 'create' };
-    return match === undefined
-        ? [create, ...others]
-        : [{ kind: 'existing', project: match }, create, ...others];
-}
-const NAME_RULE = 'Names use lowercase letters, numbers and single hyphens, up to 58 characters.';
-function nameProblem(name, projects) {
-    if (projectNameFrom(name) !== name)
-        return NAME_RULE;
-    return projects.some((project) => project.name === name)
-        ? `This team already has a project called ${name}.`
-        : null;
-}
-function givenName(name, projects) {
-    const problem = name === null ? NAME_RULE : nameProblem(name, projects);
-    if (name === null || problem !== null) {
-        throw new CliError('needs_a_name', `${problem ?? NAME_RULE}\nName the project with --name.`, '--name');
-    }
-    return name;
-}
-async function askProjectName(projects, suggestion) {
-    let offered = suggestion;
-    for (;;) {
-        const answer = await askText('Project name', offered, '--name');
-        const problem = nameProblem(answer, projects);
-        if (problem === null)
-            return answer;
-        process.stdout.write(`${failure(problem)}\n`);
-        offered = projectNameFrom(answer);
-    }
-}
-async function destinationFor(api, root, options) {
-    if (options.name !== undefined && projectIsNamed()) {
-        throw new CliError('name_and_project', '--name creates a new project and --project names an existing one.\nGive one of them.', '--name');
-    }
-    if (projectIsNamed()) {
-        return {
-            kind: 'project',
-            project: await resolveProject(api, { followLink: false }),
-            isLinked: false,
-        };
-    }
-    const link = await findLink(root);
-    if (link !== null) {
-        const answer = await api.GET('/api/projects/{id}', {
-            params: { path: { id: link.projectId } },
-        });
-        if (answer.response.status !== 404) {
-            if (options.name !== undefined) {
-                throw new CliError('already_linked', 'This folder is already linked to a project.\nRun grayspar unlink to deploy it as a new one.', '--name');
-            }
-            return {
-                kind: 'project',
-                project: await dataOrThrow(Promise.resolve(answer)),
-                isLinked: true,
-            };
-        }
-        printNote(options.format, 'The project this folder was linked to no longer exists.');
-    }
-    const team = await resolveTeam(api, { takeDefault: options.yes, deploying: true });
-    const projects = await teamProjects(api, team.id);
-    if (options.name !== undefined) {
-        return { kind: 'new', team, name: givenName(options.name, projects) };
-    }
-    const suggestion = projectNameFrom(basename(root));
-    const destinations = destinationOptions(projects, suggestion);
-    const [suggested] = destinations;
-    if (suggested === undefined)
-        throw new Error('There is always a project to create.');
-    if (options.yes) {
-        return suggested.kind === 'existing'
-            ? { kind: 'project', project: suggested.project, isLinked: false }
-            : { kind: 'new', team, name: givenName(suggestion, projects) };
-    }
-    if (!isInteractive()) {
-        throw new CliError('needs_an_answer', 'This folder is not linked to a project yet, and there is no terminal to ask which.\nDeploy to a new project with --name, or to an existing one with --project.', '--name');
-    }
-    const picked = await askChoice('Select a project', 'Project', destinations.map((option, index) => ({
-        value: String(index),
-        label: option.kind === 'create' ? 'Create a new project' : option.project.name,
-    })), '--project');
-    const choice = destinations[Number(picked)] ?? suggested;
-    const destination = choice.kind === 'existing'
-        ? { kind: 'project', project: choice.project, isLinked: false }
-        : { kind: 'new', team, name: await askProjectName(projects, suggestion) };
-    process.stdout.write('\n');
-    return destination;
+    await printDeployFailure(api, project, outcome);
 }
 export const deployCommand = new Command('deploy')
-    .argument('[directory]', 'the project folder to deploy', '.')
+    .argument('[folder]', 'deploy only the files under this folder of the project', '.')
     .description('build a project folder and put it online')
     .option('-y, --yes', 'take the plan as shown without asking')
     .option('--name <name>', 'create a new project with this name')
@@ -345,6 +187,7 @@ export const deployCommand = new Command('deploy')
     .addOption(new Option('--env-conflict <winner>', 'which value wins where your .env differs from a saved one').choices(['saved', 'file']))
     .option('-s, --service <name>', 'deploy only this service, repeatable', collectRepeatedValue)
     .option('--path <name=path>', 'where a new service answers, repeatable', collectRepeatedValue)
+    .option('--no-path <name>', 'a new service that takes no requests, like a background worker', (name, paths) => collectRepeatedValue(`${name}=${NO_PATH_VALUE}`, paths))
     .option('--dockerfile <name=path>', 'the Dockerfile a new service builds from', collectRepeatedValue)
     .option('--volume <name=path>', 'a folder a service keeps across deploys, repeatable', collectRepeatedValue)
     .action(commandAction((format, command, folder) => {
@@ -355,7 +198,7 @@ export const deployCommand = new Command('deploy')
         name: options.name,
         env: options.env,
         envFile: options.envFile,
-        preference: options.envConflict,
+        envConflict: options.envConflict,
         flags: {
             services: options.service ?? [],
             paths: options.path ?? [],

package/dist/commands/deploy/env-files.js

@@ -1,22 +1,20 @@
-/* A variable found beside the service beats one at the repository root, and an example file is read for its names
-   alone, because its values are placeholders. A variable Grayspar sets itself is left out wherever it is found. */
+/* A variable found beside the service beats one at the repository root, and a variable Grayspar sets itself is left
+   out wherever it is found. */
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { parseEnv } from 'node:util';
 import { CliError } from '../../lib/errors.js';
 const ENV_FILES_IN_ORDER = ['.env', '.env.production', '.env.local'];
-const EXAMPLE_ENV_FILES = ['.env.example', '.env.sample', '.env.template'];
 export function emptyFoundVariables() {
-    return { values: {}, sourceFiles: {}, skippedPlatformVariables: {}, expectedButMissing: [] };
+    return { values: {}, sourceFiles: {}, skippedPlatformVariables: {} };
 }
 async function readIfPresent(folder, file) {
-    return readFile(join(folder, file), 'utf8').catch(() => null);
+    return readFile(resolve(folder, file), 'utf8').catch(() => null);
 }
 export async function variablesFor(root, serviceFolder, platformVariableNames, envFile) {
     const values = {};
     const sourceFiles = {};
     const skippedPlatformVariables = {};
-    const expected = new Set();
     function takeVariables(raw, origin) {
         for (const [name, value] of Object.entries(parseEnv(raw))) {
             if (value === undefined)
@@ -37,27 +35,13 @@ export async function variablesFor(root, serviceFolder, platformVariableNames, e
                 continue;
             takeVariables(raw, place === '.' ? file : `${place}/${file}`);
         }
-        for (const file of EXAMPLE_ENV_FILES) {
-            const raw = await readIfPresent(join(root, place), file);
-            if (raw === null)
-                continue;
-            for (const name of Object.keys(parseEnv(raw)))
-                expected.add(name);
-        }
     }
     if (envFile !== undefined) {
-        const raw = await readIfPresent(root, envFile);
+        const raw = await readIfPresent(process.cwd(), envFile);
         if (raw === null) {
             throw new CliError('no_env_file', `No environment file at ${envFile}.\nGive the path of an existing file with --env-file.`, '--env-file');
         }
         takeVariables(raw, envFile);
     }
-    return {
-        values,
-        sourceFiles,
-        skippedPlatformVariables,
-        expectedButMissing: [...expected]
-            .filter((name) => !(name in values) && !platformVariableNames.includes(name))
-            .sort(),
-    };
+    return { values, sourceFiles, skippedPlatformVariables };
 }

package/dist/commands/deploy/git-state.js

@@ -1,20 +1,33 @@
 /* A deploy uploads the files on disk and names the commit only to describe them, so a tree with
-   uncommitted or untracked files says it holds changes beyond that commit. */
+   uncommitted or untracked files says it holds changes beyond that commit. Only the deployed folder counts. */
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
 const GIT_TIMEOUT_MS = 5000;
+const NO_COMMIT_YET = '(initial)';
+const DETACHED = '(detached)';
 async function runGit(folder, args) {
     const { stdout } = await execFileAsync('git', args, { cwd: folder, timeout: GIT_TIMEOUT_MS });
     return stdout.trim();
 }
 export async function gitStateOf(folder) {
     try {
-        const commit = await runGit(folder, ['rev-parse', 'HEAD']);
-        const branch = await runGit(folder, ['rev-parse', '--abbrev-ref', 'HEAD']);
-        const message = await runGit(folder, ['log', '-1', '--format=%s']);
-        const changes = await runGit(folder, ['status', '--porcelain']);
-        return { branch: branch === 'HEAD' ? null : branch, commit, message, dirty: changes !== '' };
+        const [status, message] = await Promise.all([
+            runGit(folder, ['status', '--porcelain=v2', '--branch', '--', '.']),
+            runGit(folder, ['log', '-1', '--format=%s']),
+        ]);
+        const lines = status.split('\n');
+        const header = (name) => lines.find((line) => line.startsWith(`# ${name} `))?.slice(`# ${name} `.length);
+        const commit = header('branch.oid');
+        const branch = header('branch.head');
+        if (commit === undefined || commit === NO_COMMIT_YET)
+            return null;
+        return {
+            branch: branch === undefined || branch === DETACHED ? null : branch,
+            commit,
+            message,
+            dirty: lines.some((line) => line !== '' && !line.startsWith('#')),
+        };
     }
     catch {
         return null;