entrify-deploy 1.2.0 → 1.3.0

package/dist/cli.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import { createInterface } from 'node:readline';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { cwd as processCwd } from 'node:process';
 import { readCredentials, clearCredentials, login, PRODUCTION_URL } from './auth.js';
 import { EntrifyApi } from './api.js';
 import { getGitInfo, validateLocal } from './detector.js';
-import { buildDeployUrl, cliName, normaliseRepoUrl, parseArgs } from './util.js';
+import { CliError, EXIT, buildDeployUrl, cliName, normaliseRepoUrl, parseArgs, parseDotenv, previousDeployed, projectNameFromRepo, } from './util.js';
 /** `entrify` or `dropdeploy`, whichever was typed. */
 const BIN = cliName();
 // ── ANSI colours (no external dep) ──────────────────────────────────────────
@@ -16,6 +18,30 @@ const c = {
     bold: (s) => `\x1b[1m${s}\x1b[0m`,
     dim: (s) => `\x1b[2m${s}\x1b[0m`,
 };
+// ── Output: human text, or exactly one JSON object with --json ──────────────
+let jsonMode = false;
+/** Human-readable output. Silent with --json, so stdout carries only the JSON result. */
+function say(...args) {
+    if (!jsonMode)
+        console.log(...args);
+}
+function sayInline(text) {
+    if (!jsonMode)
+        process.stdout.write(text);
+}
+/** A command's result. With --json it is printed as `{ "ok": true, ... }`; humans have already been told. */
+function emit(result) {
+    if (jsonMode)
+        process.stdout.write(JSON.stringify({ ok: true, ...result }) + '\n');
+}
+function colourStatus(status) {
+    if (!status)
+        return c.dim('no deployments');
+    if (status === 'DEPLOYED')
+        return c.green(status);
+    return status === 'FAILED' ? c.red(status) : c.yellow(status);
+}
+const publicProject = (p) => ({ id: p.id, slug: p.slug, name: p.name });
 // ── Interactive prompt ───────────────────────────────────────────────────────
 async function prompt(question) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -102,17 +128,32 @@ function renderBar(percent, label) {
 }
 const isTTY = process.stdout.isTTY ?? false;
 function printProgress(percent, label) {
-    if (!isTTY)
+    if (!isTTY || jsonMode)
         return;
     process.stdout.write('\r' + renderBar(percent, label) + '  ');
 }
 function clearProgress() {
-    if (!isTTY)
+    if (!isTTY || jsonMode)
         return;
     process.stdout.write('\r' + ' '.repeat(72) + '\r');
 }
 // ── Error diagnosis from build log tail ─────────────────────────────────────
 const ERROR_PATTERNS = [
+    {
+        re: /no space left on device/i,
+        cause: 'The Entrify server ran out of disk space',
+        fix: 'Not a problem in your code: ask the Entrify admin to free space, then redeploy',
+    },
+    {
+        re: /did not start listening/i,
+        cause: 'The app never accepted connections on its port',
+        fix: 'Listen on 0.0.0.0 (not 127.0.0.1 or localhost) and on the PORT environment variable',
+    },
+    {
+        re: /exited during startup/i,
+        cause: 'The app crashed while starting',
+        fix: `Read the error above; if it asks for a setting, add it with \`${BIN} env set KEY=VALUE\` and redeploy`,
+    },
     {
         re: /Cannot find module|Module not found/i,
         cause: 'Missing dependency',
@@ -157,164 +198,82 @@ function diagnose(log) {
     }
     return null;
 }
-// ── Project selection ────────────────────────────────────────────────────────
-async function pickProject(api, remoteUrl, localBranch, flagProjectId) {
+// ── Auth ─────────────────────────────────────────────────────────────────────
+async function requireCreds() {
+    const creds = await readCredentials();
+    if (!creds)
+        throw new CliError(`Not logged in. Run: ${BIN} auth login`, 'NOT_LOGGED_IN', EXIT.AUTH);
+    return creds;
+}
+async function createProjectFromRemote(api, { remoteUrl, branch, detectedType }) {
+    const repo = normaliseRepoUrl(remoteUrl);
+    const host = repo.split('/')[0];
+    const source = host === 'github.com' ? 'GITHUB' : host.includes('gitlab') ? 'GITLAB' : null;
+    if (!source) {
+        throw new CliError(`Only GitHub and GitLab repositories can be deployed (this remote is on ${host}).`, 'UNSUPPORTED_REMOTE', EXIT.NEEDS_INPUT);
+    }
+    return api.createProject({
+        name: projectNameFromRepo(remoteUrl),
+        source,
+        githubUrl: `https://${repo}`,
+        type: detectedType ?? undefined,
+        branch: branch === 'HEAD' ? undefined : branch,
+    });
+}
+async function pickProject(api, query) {
     const projects = await api.listProjects();
-    if (flagProjectId) {
-        const p = projects.find((p) => p.id === flagProjectId || p.slug === flagProjectId);
-        if (!p)
-            throw new Error(`Project "${flagProjectId}" not found`);
-        return p;
+    if (query.projectId) {
+        const p = projects.find((p) => p.id === query.projectId || p.slug === query.projectId);
+        if (!p) {
+            throw new CliError(`Project "${query.projectId}" not found. List them with: ${BIN} projects`, 'PROJECT_NOT_FOUND', EXIT.NEEDS_INPUT);
+        }
+        return { project: p, created: false };
     }
     // Auto-match by git remote URL (HTTPS or SSH); with several projects on one repo, prefer this branch's
-    if (remoteUrl) {
-        const needle = normaliseRepoUrl(remoteUrl);
+    if (query.remoteUrl) {
+        const needle = normaliseRepoUrl(query.remoteUrl);
         const matches = projects.filter((p) => p.githubUrl && normaliseRepoUrl(p.githubUrl) === needle);
-        if (matches.length > 0)
-            return matches.find((p) => p.branch === localBranch) ?? matches[0];
+        if (matches.length > 0) {
+            return { project: matches.find((p) => p.branch === query.branch) ?? matches[0], created: false };
+        }
+        if (query.create) {
+            const project = await createProjectFromRemote(api, { remoteUrl: query.remoteUrl, branch: query.branch, ...query.create });
+            return { project, created: true };
+        }
     }
+    const hint = `Pass --project-id <id|slug> (list them with: ${BIN} projects), or deploy with --create to make a new project from this repository.`;
     if (projects.length === 0) {
-        throw new Error('No projects found on Entrify. Create one from the dashboard first.');
+        throw new CliError(`No projects found on Entrify. ${hint}`, 'NO_PROJECTS', EXIT.NEEDS_INPUT);
     }
-    // Without a terminal (CI) the prompt below would wait forever.
-    if (!process.stdin.isTTY) {
-        throw new Error(`No project matches this repository. Pass --project-id <id|slug> (list them with: ${BIN} projects).`);
+    // Without a terminal (CI, coding agents) or with --json, nobody can answer the prompt below.
+    if (!process.stdin.isTTY || jsonMode) {
+        throw new CliError(`No project matches this repository. ${hint}`, 'NO_PROJECT_MATCH', EXIT.NEEDS_INPUT);
     }
-    // Prompt user to pick
-    console.log(`\n${c.bold('Select a project:')}`);
+    say(`\n${c.bold('Select a project:')}`);
     projects.forEach((p, i) => {
-        const latest = p.deployments?.[0];
-        const status = latest
-            ? latest.status === 'DEPLOYED'
-                ? c.green(latest.status)
-                : latest.status === 'FAILED'
-                    ? c.red(latest.status)
-                    : c.yellow(latest.status)
-            : c.dim('no deployments');
-        console.log(`  ${c.cyan(String(i + 1))}) ${p.name}  ${c.dim(`(${p.slug})`)}  ${status}`);
+        say(`  ${c.cyan(String(i + 1))}) ${p.name}  ${c.dim(`(${p.slug})`)}  ${colourStatus(p.deployments?.[0]?.status)}`);
     });
     const answer = await prompt(`\nEnter number [1-${projects.length}]: `);
     const idx = parseInt(answer, 10) - 1;
     if (isNaN(idx) || idx < 0 || idx >= projects.length) {
-        throw new Error('Invalid selection');
+        throw new CliError('Invalid selection', 'INVALID_SELECTION', EXIT.NEEDS_INPUT);
     }
-    return projects[idx];
+    return { project: projects[idx], created: false };
 }
-// ── Commands ─────────────────────────────────────────────────────────────────
-async function cmdAuthLogin(flags) {
-    const apiUrl = flags['api-url'] ?? PRODUCTION_URL;
-    console.log(`Connecting to ${c.cyan(apiUrl)}`);
-    const email = flags['email'] ?? (await prompt('Email: '));
-    const password = await promptHidden('Password: ');
-    process.stdout.write('Logging in… ');
-    const creds = await login(apiUrl, email, password);
-    console.log(c.green('✓'));
-    console.log(`Logged in as ${c.bold(creds.email)}`);
-}
-async function cmdAuthStatus() {
-    const creds = await readCredentials();
-    if (!creds) {
-        console.log(`${c.yellow('Not logged in.')} Run: ${BIN} auth login`);
-        process.exit(1);
-    }
-    console.log(`${c.green('✓')} Logged in as ${c.bold(creds.email)}`);
-    console.log(`  API: ${c.dim(creds.apiUrl)}`);
-}
-async function cmdAuthLogout() {
-    await clearCredentials();
-    console.log(`${c.green('✓')} Logged out`);
-}
-async function cmdProjects() {
-    const creds = await readCredentials();
-    if (!creds) {
-        console.error(c.red('Not logged in.') + ` Run: ${BIN} auth login`);
-        process.exit(1);
-    }
-    const api = new EntrifyApi(creds);
-    const projects = await api.listProjects();
-    if (projects.length === 0) {
-        console.log('No projects found.');
-        return;
-    }
-    console.log(`\n${c.bold('Your projects:')}`);
-    for (const p of projects) {
-        const latest = p.deployments?.[0];
-        const statusStr = latest
-            ? latest.status === 'DEPLOYED'
-                ? c.green(latest.status)
-                : latest.status === 'FAILED'
-                    ? c.red(latest.status)
-                    : c.yellow(latest.status)
-            : c.dim('no deployments');
-        console.log(`  ${c.cyan(p.slug)}  ${p.name}  ${statusStr}`);
-        if (latest?.subdomain) {
-            console.log(`    ${c.dim('→ ' + buildDeployUrl(creds.apiUrl, latest.subdomain))}`);
-        }
-    }
-    console.log();
+/** The project for the repository in --dir (or the current directory), or --project-id. Never creates one. */
+async function resolveProject(api, flags) {
+    const git = await getGitInfo(flags['dir'] ?? processCwd());
+    const { project } = await pickProject(api, { remoteUrl: git.remoteUrl, branch: git.branch, projectId: flags['project-id'] ?? null });
+    return project;
 }
-async function cmdDeploy(flags) {
-    const dir = flags['dir'] ?? processCwd();
-    // ── 1. Auth check ──────────────────────────────────────────────────────────
-    const creds = await readCredentials();
-    if (!creds) {
-        console.error(c.red('Not logged in.') + ` Run: ${BIN} auth login`);
-        process.exit(1);
-    }
-    const api = new EntrifyApi(creds);
-    console.log(`\n${c.bold('▶ Entrify')}\n`);
-    // ── 2. Git info ───────────────────────────────────────────────────────────
-    process.stdout.write('  Checking repository… ');
-    const gitInfo = await getGitInfo(dir);
-    console.log(c.green('✓'));
-    if (gitInfo.isDirty) {
-        console.log(`  ${c.yellow('⚠')}  Working tree has uncommitted changes`);
-    }
-    // ── 3. Validate ───────────────────────────────────────────────────────────
-    process.stdout.write('  Validating project… ');
-    const validation = await validateLocal(dir, gitInfo);
-    if (!validation.ok) {
-        console.log(c.red('✗'));
-        for (const e of validation.errors) {
-            console.error(`  ${c.red('✗')}  ${e}`);
-        }
-        process.exit(1);
-    }
-    console.log(c.green('✓'));
-    for (const w of validation.warnings) {
-        console.log(`  ${c.yellow('⚠')}  ${w}`);
-    }
-    // ── 4. Framework detection ────────────────────────────────────────────────
-    if (gitInfo.remoteUrl) {
-        process.stdout.write('  Detecting framework… ');
-        try {
-            const detected = await api.detectType(gitInfo.remoteUrl, gitInfo.branch);
-            console.log(`${c.green('✓')}  ${c.bold(detected.type)} ${c.dim(`(${detected.hint})`)}`);
-        }
-        catch {
-            console.log(c.dim('skipped'));
-        }
-    }
-    // ── 5. Project resolution ──────────────────────────────────────────────────
-    process.stdout.write('  Resolving project… ');
-    const project = await pickProject(api, gitInfo.remoteUrl, gitInfo.branch, flags['project-id'] ?? null);
-    console.log(`${c.green('✓')}  ${c.bold(project.name)} ${c.dim(`(${project.slug})`)}`);
-    // The server builds the project's branch, not whatever is checked out here.
-    if (project.branch && gitInfo.branch !== 'HEAD' && gitInfo.branch !== project.branch) {
-        console.log(`  ${c.yellow('⚠')}  This project deploys branch ${c.bold(project.branch)}; you are on ${c.bold(gitInfo.branch)}.`);
-    }
-    // ── 6. Trigger deployment ──────────────────────────────────────────────────
-    process.stdout.write('  Triggering deployment… ');
-    const { deploymentId, queued } = await api.triggerDeploy(project.id);
-    console.log(c.green('✓') + (queued ? c.dim('  (queued behind active build)') : ''));
-    console.log();
-    // ── 7. Stream logs + live progress bar ────────────────────────────────────
+/** Streams the build log (with a progress bar for humans), then waits for the final status. */
+async function followDeployment(api, projectId, deploymentId) {
     const logLines = [];
-    let currentStep = '';
+    let currentStep = null;
     let currentPercent = 5;
     printProgress(currentPercent, 'Waiting in queue…');
     try {
-        for await (const evt of api.streamLogs(project.id, deploymentId)) {
+        for await (const evt of api.streamLogs(projectId, deploymentId)) {
             if (evt.type === 'line') {
                 logLines.push(evt.text);
                 const step = detectBuildStep(evt.text);
@@ -322,12 +281,12 @@ async function cmdDeploy(flags) {
                     currentStep = step;
                     currentPercent = STEP_PERCENT[step];
                     clearProgress();
-                    console.log(`\n  ${c.cyan('›')}  ${c.bold(STEP_LABEL[step])}`);
+                    say(`\n  ${c.cyan('›')}  ${c.bold(STEP_LABEL[step])}`);
                     printProgress(currentPercent, STEP_LABEL[step] + '…');
                 }
                 else {
                     clearProgress();
-                    console.log(`  ${c.dim(evt.text)}`);
+                    say(`  ${c.dim(evt.text)}`);
                     printProgress(currentPercent, currentStep ? STEP_LABEL[currentStep] + '…' : 'Building…');
                 }
             }
@@ -348,26 +307,23 @@ async function cmdDeploy(flags) {
     }
     catch {
         clearProgress();
-        console.log(`  ${c.yellow('⚠')}  Log stream disconnected — polling for result…`);
+        say(`  ${c.yellow('⚠')}  Log stream disconnected — polling for result…`);
     }
-    // ── 8. Fetch final status ──────────────────────────────────────────────────
     clearProgress();
-    let finalStatus = null;
+    // SSE ends slightly before DB is updated — poll with exponential backoff
     let finalLog = null;
     let subdomain = null;
-    // SSE ends slightly before DB is updated — poll with exponential backoff
     let consecutiveErrors = 0;
     for (let attempt = 0; attempt < 20; attempt++) {
         const delay = Math.min(1000 * 2 ** attempt, 10_000);
         await new Promise((r) => setTimeout(r, delay));
         try {
-            const s = await api.getDeploymentStatus(project.id, deploymentId);
+            const s = await api.getDeploymentStatus(projectId, deploymentId);
             consecutiveErrors = 0;
             finalLog = s.buildLog;
             subdomain = s.subdomain;
-            if (['DEPLOYED', 'FAILED', 'CANCELLED'].includes(s.status)) {
-                finalStatus = s.status;
-                break;
+            if (s.status === 'DEPLOYED' || s.status === 'FAILED' || s.status === 'CANCELLED') {
+                return { status: s.status, subdomain, log: finalLog ?? logLines.join(''), step: currentStep };
             }
         }
         catch {
@@ -375,48 +331,305 @@ async function cmdDeploy(flags) {
                 break;
         }
     }
-    // ── 9. Final output ────────────────────────────────────────────────────────
-    console.log();
-    if (finalStatus === 'DEPLOYED') {
-        console.log(c.bold(c.green('✓ Deployed successfully')));
-        if (subdomain) {
-            const url = buildDeployUrl(creds.apiUrl, subdomain);
-            console.log(`\n  ${c.bold('Live URL')}  →  ${c.cyan(url)}`);
+    return { status: 'TIMEOUT', subdomain, log: finalLog ?? logLines.join(''), step: currentStep };
+}
+/** Prints the result of a deploy or rollback; a deployment that did not go live is thrown as a CliError. */
+function reportDeployment({ creds, project, deploymentId, outcome, details }) {
+    const base = { project: publicProject(project), deploymentId, status: outcome.status, ...details };
+    say();
+    if (outcome.status === 'DEPLOYED') {
+        const url = outcome.subdomain ? buildDeployUrl(creds.apiUrl, outcome.subdomain) : null;
+        say(c.bold(c.green('✓ Deployed successfully')));
+        if (url)
+            say(`\n  ${c.bold('Live URL')}  →  ${c.cyan(url)}`);
+        say();
+        emit({ ...base, url });
+        return;
+    }
+    if (outcome.status === 'FAILED') {
+        say(c.bold(c.red(`✗ Deployment failed${outcome.step ? ` at: ${c.bold(outcome.step)}` : ''}`)));
+        say();
+        const lines = outcome.log.split('\n').filter(Boolean);
+        const diagnosis = outcome.log ? diagnose(outcome.log) : null;
+        if (lines.length > 0) {
+            say(`  ${c.dim('Last 20 lines of build log:')}`);
+            say('  ' + '─'.repeat(52));
+            for (const l of lines.slice(-20))
+                say(`  ${c.dim(l)}`);
+            say('  ' + '─'.repeat(52));
+            say();
+            if (diagnosis) {
+                say(`  ${c.yellow('Probable cause:')}  ${diagnosis.cause}`);
+                say(`  ${c.cyan('Suggested fix:')}   ${diagnosis.fix}`);
+                say();
+            }
+        }
+        throw new CliError(`Deployment failed${outcome.step ? ` at ${outcome.step}` : ''}`, 'DEPLOY_FAILED', EXIT.FAILED, {
+            ...base,
+            step: outcome.step,
+            cause: diagnosis?.cause ?? null,
+            fix: diagnosis?.fix ?? null,
+            logTail: lines.slice(-40),
+        });
+    }
+    if (outcome.status === 'CANCELLED') {
+        throw new CliError('The deployment was cancelled.', 'DEPLOY_CANCELLED', EXIT.FAILED, base);
+    }
+    const dashboard = `${creds.apiUrl}/projects/${project.id}`;
+    throw new CliError(`Timed out waiting for the deployment to finish. Check: ${BIN} status, or ${dashboard}`, 'DEPLOY_TIMEOUT', EXIT.FAILED, { ...base, dashboard });
+}
+// ── Commands ─────────────────────────────────────────────────────────────────
+async function cmdAuthLogin(flags) {
+    const apiUrl = flags['api-url'] ?? PRODUCTION_URL;
+    console.log(`Connecting to ${c.cyan(apiUrl)}`);
+    const email = flags['email'] ?? (await prompt('Email: '));
+    const password = await promptHidden('Password: ');
+    process.stdout.write('Logging in… ');
+    const creds = await login(apiUrl, email, password);
+    console.log(c.green('✓'));
+    console.log(`Logged in as ${c.bold(creds.email)}`);
+}
+async function cmdAuthStatus() {
+    const creds = await requireCreds();
+    say(`${c.green('✓')} Logged in as ${c.bold(creds.email)}`);
+    say(`  API: ${c.dim(creds.apiUrl)}`);
+    emit({ email: creds.email, apiUrl: creds.apiUrl });
+}
+async function cmdAuthLogout() {
+    await clearCredentials();
+    say(`${c.green('✓')} Logged out`);
+    emit({});
+}
+async function cmdProjects() {
+    const creds = await requireCreds();
+    const projects = await new EntrifyApi(creds).listProjects();
+    const rows = projects.map((p) => {
+        const latest = p.deployments?.[0];
+        return { ...publicProject(p), type: p.type, status: latest?.status ?? null, url: latest?.subdomain ? buildDeployUrl(creds.apiUrl, latest.subdomain) : null };
+    });
+    if (rows.length === 0)
+        say('No projects found.');
+    else {
+        say(`\n${c.bold('Your projects:')}`);
+        for (const r of rows) {
+            say(`  ${c.cyan(r.slug)}  ${r.name}  ${colourStatus(r.status ?? undefined)}`);
+            if (r.url)
+                say(`    ${c.dim('→ ' + r.url)}`);
+        }
+        say();
+    }
+    emit({ projects: rows });
+}
+async function cmdDeploy(flags) {
+    const dir = flags['dir'] ?? processCwd();
+    const creds = await requireCreds();
+    const api = new EntrifyApi(creds);
+    const warnings = [];
+    const warn = (w) => {
+        warnings.push(w);
+        say(`  ${c.yellow('⚠')}  ${w}`);
+    };
+    say(`\n${c.bold('▶ Entrify')}\n`);
+    sayInline('  Checking repository… ');
+    const gitInfo = await getGitInfo(dir);
+    say(c.green('✓'));
+    if (gitInfo.isDirty)
+        warn('Working tree has uncommitted changes. Entrify deploys what is pushed, not local files.');
+    sayInline('  Validating project… ');
+    const validation = await validateLocal(dir, gitInfo);
+    if (!validation.ok) {
+        say(c.red('✗'));
+        for (const e of validation.errors)
+            say(`  ${c.red('✗')}  ${e}`);
+        throw new CliError(validation.errors.join(' '), 'INVALID_PROJECT', EXIT.NEEDS_INPUT, { errors: validation.errors });
+    }
+    say(c.green('✓'));
+    validation.warnings.forEach(warn);
+    let detectedType = null;
+    if (gitInfo.remoteUrl) {
+        sayInline('  Detecting framework… ');
+        try {
+            const detected = await api.detectType(gitInfo.remoteUrl, gitInfo.branch);
+            detectedType = detected.type;
+            say(`${c.green('✓')}  ${c.bold(detected.type)} ${c.dim(`(${detected.hint})`)}`);
         }
-        console.log();
+        catch {
+            say(c.dim('skipped'));
+        }
+    }
+    sayInline('  Resolving project… ');
+    const { project, created } = await pickProject(api, {
+        remoteUrl: gitInfo.remoteUrl,
+        branch: gitInfo.branch,
+        projectId: flags['project-id'] ?? null,
+        create: flags['create'] === 'true' ? { detectedType } : undefined,
+    });
+    say(`${c.green('✓')}  ${c.bold(project.name)} ${c.dim(`(${project.slug})`)}${created ? c.dim('  (new project)') : ''}`);
+    if (project.source === 'UPLOAD') {
+        throw new CliError(`"${project.slug}" was created by uploading files, so there is no repository to build. Upload a new version from the dashboard: ${creds.apiUrl}/projects/${project.id}`, 'UPLOAD_PROJECT', EXIT.NEEDS_INPUT);
+    }
+    // The server builds the project's branch, not whatever is checked out here.
+    if (project.branch && gitInfo.branch !== 'HEAD' && gitInfo.branch !== project.branch) {
+        warn(`This project deploys branch ${project.branch}; you are on ${gitInfo.branch}.`);
+    }
+    sayInline('  Triggering deployment… ');
+    const { deploymentId, queued } = await api.triggerDeploy(project.id);
+    say(c.green('✓') + (queued ? c.dim('  (queued behind active build)') : ''));
+    say();
+    const outcome = await followDeployment(api, project.id, deploymentId);
+    reportDeployment({ creds, project, deploymentId, outcome, details: { created, warnings } });
+}
+async function cmdStatus(flags) {
+    const creds = await requireCreds();
+    const api = new EntrifyApi(creds);
+    const project = await resolveProject(api, flags);
+    const deployments = await api.listDeployments(project.id, 10);
+    const latest = deployments[0] ?? null;
+    const live = deployments.find((d) => d.status === 'DEPLOYED' && d.subdomain);
+    const url = live?.subdomain ? buildDeployUrl(creds.apiUrl, live.subdomain) : null;
+    say(`\n${c.bold(project.name)} ${c.dim(`(${project.slug})`)}`);
+    say(`  Latest:  ${colourStatus(latest?.status)}${latest ? c.dim(`  ${latest.createdAt}  ${latest.id}`) : ''}`);
+    say(`  Live:    ${url ? c.cyan(url) : c.dim('not live')}\n`);
+    emit({
+        project: publicProject(project),
+        latest: latest && { id: latest.id, status: latest.status, createdAt: latest.createdAt, commitHash: latest.commitHash ?? null },
+        url,
+    });
+}
+async function cmdLogs(flags) {
+    const creds = await requireCreds();
+    const api = new EntrifyApi(creds);
+    const project = await resolveProject(api, flags);
+    const deploymentId = flags['deployment'] ?? (await api.listDeployments(project.id, 1))[0]?.id;
+    if (!deploymentId)
+        throw new CliError('This project has no deployments yet.', 'NO_DEPLOYMENTS', EXIT.NEEDS_INPUT);
+    const lineLimit = flags['lines'] === 'all' ? Infinity : Number(flags['lines'] ?? 200);
+    if (!(lineLimit > 0))
+        throw new CliError('--lines takes a positive number or "all".', 'USAGE', EXIT.NEEDS_INPUT);
+    const tailOf = (text) => {
+        const lines = text.split('\n').filter(Boolean);
+        return Number.isFinite(lineLimit) ? lines.slice(-lineLimit) : lines;
+    };
+    const current = await api.getDeploymentStatus(project.id, deploymentId);
+    let status = current.status;
+    let tail = tailOf(current.buildLog ?? '');
+    for (const l of tail)
+        say(l);
+    if (flags['follow'] === 'true' && (status === 'QUEUED' || status === 'BUILDING')) {
+        // Prints each new line as it arrives, after the lines above.
+        const outcome = await followDeployment(api, project.id, deploymentId);
+        status = outcome.status;
+        tail = tailOf(outcome.log);
+    }
+    say(`\n${c.dim('Deployment')} ${deploymentId}  ${colourStatus(status)}`);
+    emit({ project: publicProject(project), deploymentId, status, lines: tail });
+}
+/** `KEY=VALUE` to a pair. Errors name the key only, never the value. */
+function parsePair(arg) {
+    const eq = arg.indexOf('=');
+    if (eq < 1)
+        throw new CliError(`Expected KEY=VALUE, got "${arg.split('=')[0]}"`, 'USAGE', EXIT.NEEDS_INPUT);
+    return [arg.slice(0, eq), arg.slice(eq + 1)];
+}
+async function cmdEnv(sub, args, flags) {
+    const creds = await requireCreds();
+    const api = new EntrifyApi(creds);
+    const project = await resolveProject(api, flags);
+    const existing = await api.listEnv(project.id);
+    const applyHint = `Redeploy to apply: ${BIN} deploy`;
+    if (sub === undefined || sub === 'list') {
+        if (existing.length === 0)
+            say('No environment variables set.');
+        for (const v of existing)
+            say(`  ${c.cyan(v.key)}  ${c.dim(v.environment)}`);
+        emit({ project: publicProject(project), variables: existing.map((v) => ({ key: v.key, environment: v.environment })) });
         return;
     }
-    if (finalStatus === 'FAILED') {
-        const stepLabel = currentStep ? ` at: ${c.bold(currentStep)}` : '';
-        console.log(c.bold(c.red(`✗ Deployment failed${stepLabel}`)));
-        console.log();
-        const log = finalLog ?? logLines.join('');
-        if (log) {
-            const tail = log
-                .split('\n')
-                .filter(Boolean)
-                .slice(-20)
-                .join('\n');
-            console.log(`  ${c.dim('Last 20 lines of build log:')}`);
-            console.log('  ' + '─'.repeat(52));
-            for (const l of tail.split('\n')) {
-                console.log(`  ${c.dim(l)}`);
+    if (sub === 'set' || sub === 'push') {
+        let pairs;
+        if (sub === 'push') {
+            const file = resolve(flags['dir'] ?? processCwd(), args[0] ?? '.env');
+            const text = await readFile(file, 'utf8').catch(() => {
+                throw new CliError(`Cannot read ${file}`, 'FILE_NOT_FOUND', EXIT.NEEDS_INPUT);
+            });
+            pairs = parseDotenv(text);
+        }
+        else {
+            pairs = args.map(parsePair);
+        }
+        if (pairs.length === 0) {
+            throw new CliError(`Nothing to set. Use: ${BIN} env set KEY=VALUE … or ${BIN} env push [.env file]`, 'USAGE', EXIT.NEEDS_INPUT);
+        }
+        // A key given twice keeps its last value, as in a .env file.
+        pairs = [...new Map(pairs)];
+        const created = [];
+        const updated = [];
+        for (const [key, value] of pairs) {
+            const found = existing.find((v) => v.key === key);
+            if (found) {
+                await api.updateEnv(project.id, found.id, value);
+                updated.push(key);
             }
-            console.log('  ' + '─'.repeat(52));
-            console.log();
-            const diagnosis = diagnose(log);
-            if (diagnosis) {
-                console.log(`  ${c.yellow('Probable cause:')}  ${diagnosis.cause}`);
-                console.log(`  ${c.cyan('Suggested fix:')}   ${diagnosis.fix}`);
-                console.log();
+            else {
+                await api.createEnv(project.id, key, value);
+                created.push(key);
+            }
+        }
+        say(`${c.green('✓')} Set ${pairs.length} variable(s) on ${c.bold(project.slug)}: ${[...created, ...updated].join(', ')}`);
+        say(c.dim(applyHint));
+        emit({ project: publicProject(project), created, updated, hint: applyHint });
+        return;
+    }
+    if (sub === 'unset') {
+        if (args.length === 0)
+            throw new CliError(`Use: ${BIN} env unset KEY …`, 'USAGE', EXIT.NEEDS_INPUT);
+        const removed = [];
+        const missing = [];
+        for (const key of args) {
+            const found = existing.find((v) => v.key === key);
+            if (!found) {
+                missing.push(key);
+                continue;
             }
+            await api.deleteEnv(project.id, found.id);
+            removed.push(key);
         }
-        process.exit(1);
+        if (removed.length)
+            say(`${c.green('✓')} Removed: ${removed.join(', ')}`);
+        if (missing.length)
+            say(`${c.yellow('⚠')}  Not set: ${missing.join(', ')}`);
+        if (removed.length)
+            say(c.dim(applyHint));
+        emit({ project: publicProject(project), removed, missing, hint: applyHint });
+        return;
     }
-    // Timed out
-    console.log(`${c.yellow('⚠')}  Timed out waiting for deployment to finish.`);
-    console.log(`   Check status at: ${c.cyan(`${creds.apiUrl}/projects/${project.id}`)}`);
-    process.exit(1);
+    throw new CliError('Unknown env subcommand. Use: list | set KEY=VALUE … | push [file] | unset KEY …', 'USAGE', EXIT.NEEDS_INPUT);
+}
+async function cmdRollback(flags) {
+    const creds = await requireCreds();
+    const api = new EntrifyApi(creds);
+    const project = await resolveProject(api, flags);
+    const targetId = flags['to'] ?? previousDeployed(await api.listDeployments(project.id, 50))?.id;
+    if (!targetId) {
+        throw new CliError('There is no earlier successful deployment to roll back to.', 'NO_ROLLBACK_TARGET', EXIT.NEEDS_INPUT);
+    }
+    sayInline(`  Rolling back ${c.bold(project.slug)} to ${c.dim(targetId)}… `);
+    const { deploymentId } = await api.rollback(project.id, targetId);
+    say(c.green('✓'));
+    const outcome = await followDeployment(api, project.id, deploymentId);
+    reportDeployment({ creds, project, deploymentId, outcome, details: { rolledBackTo: targetId } });
+}
+async function cmdCancel(flags) {
+    const creds = await requireCreds();
+    const api = new EntrifyApi(creds);
+    const project = await resolveProject(api, flags);
+    const active = flags['deployment']
+        ?? (await api.listDeployments(project.id, 10)).find((d) => d.status === 'QUEUED' || d.status === 'BUILDING')?.id;
+    if (!active)
+        throw new CliError('No deployment is queued or building.', 'NOTHING_TO_CANCEL', EXIT.NEEDS_INPUT);
+    await api.cancelDeployment(project.id, active);
+    say(`${c.green('✓')} Cancelled ${active}`);
+    emit({ project: publicProject(project), cancelled: active });
 }
 // ── Help ─────────────────────────────────────────────────────────────────────
 function cmdHelp() {
@@ -429,8 +642,20 @@ ${c.bold('USAGE')}
 ${c.bold('COMMANDS')}
   ${c.cyan('deploy')}                       Deploy the current project  ${c.dim('(default)')}
     ${c.dim('--project-id <id|slug>')}      Skip project selection and deploy to a specific project
+    ${c.dim('--create')}                    Create a project from this repository if none matches
     ${c.dim('--dir <path>')}                Use a different working directory
-
+  ${c.cyan('status')}                       Latest deployment and live URL of the current project
+  ${c.cyan('logs')}                         Build log of the latest deployment
+    ${c.dim('--deployment <id>')}           A specific deployment instead of the latest
+    ${c.dim('--lines <n|all>')}             How many lines from the end  ${c.dim('(default 200)')}
+    ${c.dim('--follow')}                    Stream a deployment that is still building
+  ${c.cyan('env list')}                     Environment variable names  ${c.dim('(values are never shown)')}
+  ${c.cyan('env set KEY=VALUE …')}          Add or change variables
+  ${c.cyan('env push [file]')}              Add or change every variable in a .env file  ${c.dim('(default .env)')}
+  ${c.cyan('env unset KEY …')}              Remove variables
+  ${c.cyan('rollback')}                     Go back to the previous successful deployment
+    ${c.dim('--to <deployment-id>')}        A specific earlier deployment
+  ${c.cyan('cancel')}                       Cancel the deployment that is queued or building
   ${c.cyan('projects')}                     List all your projects and their status
 
   ${c.cyan('auth login')}                   Log in to Entrify  ${c.dim('(default: entrify.site)')}
@@ -443,6 +668,14 @@ ${c.bold('COMMANDS')}
   ${c.cyan('help')}                         Show this help message
   ${c.cyan('--version')}                    Print the CLI version
 
+  The project is matched from the git remote of the current directory; pass
+  ${c.dim('--project-id <id|slug>')} to any project command to choose one instead.
+
+${c.bold('FOR SCRIPTS AND AI AGENTS')}
+  ${c.dim('--json')}                        Print one JSON object: ${c.dim('{ "ok": true, ... }')} or ${c.dim('{ "ok": false, "error": { "code", "message" } }')}
+  Exit codes: ${c.dim('0')} ok · ${c.dim('1')} failed · ${c.dim('2')} needs input (flag, project, file) · ${c.dim('3')} not logged in
+  Commands never prompt without a terminal or with --json.
+
 ${c.bold('ENVIRONMENT')}  ${c.dim('(the DROPDEPLOY_* names still work)')}
   ${c.dim('ENTRIFY_TOKEN')}                 Bearer token  ${c.dim('(skips auth login in CI)')}
   ${c.dim('ENTRIFY_URL')}                   Entrify URL, e.g. https://entrify.site
@@ -451,18 +684,20 @@ ${c.bold('ENVIRONMENT')}  ${c.dim('(the DROPDEPLOY_* names still work)')}
 ${c.bold('EXAMPLES')}
   ${c.dim('$')} ${BIN} auth login
   ${c.dim('$')} ${BIN} deploy
-  ${c.dim('$')} ${BIN} deploy --project-id my-app
-  ${c.dim('$')} ${BIN} projects
+  ${c.dim('$')} ${BIN} deploy --create --json
+  ${c.dim('$')} ${BIN} logs --follow
+  ${c.dim('$')} ${BIN} env push .env.production
+  ${c.dim('$')} ${BIN} rollback
 `);
 }
 // ── Entry point ───────────────────────────────────────────────────────────────
 async function main() {
     const { command, flags } = parseArgs(process.argv.slice(2));
-    const [cmd, sub] = command;
+    const [cmd, sub, ...rest] = command;
+    jsonMode = flags['json'] === 'true';
     if (flags['help'] === 'true')
         return cmdHelp();
     if (cmd === 'version' || flags['version'] === 'true') {
-        const { readFile } = await import('node:fs/promises');
         const { join, dirname } = await import('node:path');
         const { fileURLToPath } = await import('node:url');
         const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
@@ -477,21 +712,34 @@ async function main() {
             return cmdAuthStatus();
         if (sub === 'logout')
             return cmdAuthLogout();
-        console.error('Unknown auth subcommand. Use: login | status | logout');
-        process.exit(1);
+        throw new CliError('Unknown auth subcommand. Use: login | status | logout', 'USAGE', EXIT.NEEDS_INPUT);
     }
     if (cmd === 'projects')
         return cmdProjects();
     if (cmd === 'deploy' || cmd === undefined)
         return cmdDeploy(flags);
+    if (cmd === 'status')
+        return cmdStatus(flags);
+    if (cmd === 'logs')
+        return cmdLogs(flags);
+    if (cmd === 'env')
+        return cmdEnv(sub, rest, flags);
+    if (cmd === 'rollback')
+        return cmdRollback(flags);
+    if (cmd === 'cancel')
+        return cmdCancel(flags);
     if (cmd === 'help' || cmd === '--help' || cmd === '-h')
         return cmdHelp();
-    console.error(`Unknown command: ${cmd}`);
-    console.error(`Run ${BIN} help for usage.`);
-    process.exit(1);
+    throw new CliError(`Unknown command: ${cmd}. Run ${BIN} help for usage.`, 'USAGE', EXIT.NEEDS_INPUT);
 }
 main().catch((err) => {
-    console.error(`\n${c.red('Error:')} ${err.message}`);
-    process.exit(1);
+    const e = err instanceof CliError ? err : new CliError(err instanceof Error ? err.message : String(err), 'ERROR');
+    if (jsonMode) {
+        process.stdout.write(JSON.stringify({ ok: false, error: { code: e.code, message: e.message }, ...e.details }) + '\n');
+    }
+    else {
+        console.error(`\n${c.red('Error:')} ${e.message}`);
+    }
+    process.exit(e.exitCode);
 });
 //# sourceMappingURL=cli.js.map