summer-engine 4.3.0 → 4.6.0

package/dist/cli/commands/install.d.ts

@@ -1,60 +1,17 @@
 import { Command } from "commander";
-/** Guard a download URL from the releases endpoint. A missing/empty URL (an
- *  outdated or misconfigured endpoint) otherwise becomes a cryptic
- *  fetch(undefined) failure — surface it clearly with a manual fallback. */
-export declare function requireDownloadUrl(value: string | undefined, label: string): string;
-/** Verify a downloaded file's sha256 against the expected hash from the releases
- *  endpoint. Skipped when no expected hash is published. Catches a truncated or
- *  corrupted download (a ~1GB install over a flaky network) before it becomes a
- *  confusing DMG-mount / installer failure downstream. */
-export declare function verifyChecksum(actual: string, expected: string | undefined, label: string): void;
-import { parseMacBundleVersion, readMacBundleVersion } from "../../core/launch-posture.js";
-export { parseMacBundleVersion, readMacBundleVersion };
-export declare function isSameVersion(installed: string | null, latest: string): boolean;
-export type MacInstallPlan = {
-    action: "install";
-} | {
-    action: "up-to-date";
-    version: string;
-} | {
-    action: "needs-confirmation";
-    installed: string | null;
-} | {
-    action: "refuse";
-    reason: string;
-};
-/** Decide what `summer install` may do about an existing /Applications/Summer.app.
- *  Replacing an installed engine is destructive, so it needs --yes or a TTY
- *  prompt; an equal version is a no-op success. */
-export declare function planMacInstall(input: {
-    exists: boolean;
-    installedVersion: string | null;
-    latestVersion: string;
-    yes: boolean;
-    isTTY: boolean;
-}): MacInstallPlan;
-export type ShellExec = (command: string) => void;
-/** Replace destApp with the bundle on the mounted DMG WITHOUT a window where
- *  no engine exists: copy to <destApp>.new first, and only after that
- *  succeeds remove the old bundle and rename the staged copy into place. A
- *  failed copy leaves the existing install untouched. */
-export declare function replaceMacApp(mountPoint: string, destApp: string, exec: ShellExec): void;
-/** Velopack Setup.exe install args. Velopack is NOT NSIS: silent install is
- *  `--silent` and a custom directory is `--installto <dir>` (per Velopack's
- *  setup.exe CLI). The old NSIS flags (/S, /D=) are rejected by the Velopack
- *  installer with "unexpected argument '/S' found" — this is the wizard bug. */
-export declare function windowsInstallerArgs(customPath?: string): string;
-/** Printed after an install: the first start of a new engine is slow and silent. */
-export declare const FIRST_START_NOTE: string;
-/** Where the Velopack installer put Summer.exe: <dir>/current/Summer.exe for --path, else the default locations. */
-export declare function windowsInstalledBinary(customPath?: string, exists?: (path: string) => boolean): string | null;
-/**
- * Download progress: rewrites one line on a terminal; elsewhere (an agent,
- * a log file) one line per 10%, so a 1 GB download is about ten lines
- * instead of hundreds of kilobytes.
- */
-export declare function createProgressReporter(isTTY: boolean, write: (text: string) => void): (downloaded: number, total: number) => void;
+import { EngineInstallError } from "../../core/engine-install.js";
+import { installEngine } from "../../core/engine-installer.js";
+export * from "../../core/engine-installer.js";
+/** The coded failure an error from installEngine stands for, or null for a
+ *  bug (rethrown as before). A raw ENOSPC/EACCES/EPERM still gets its code. */
+export declare function installCommandFailure(err: unknown): EngineInstallError | null;
+/** `summer install`: installEngine with a printed, coded failure and exit code 1. */
+export declare function runInstallCommand(opts: {
+    path?: string;
+    yes?: boolean;
+}, deps?: {
+    install?: typeof installEngine;
+    error?: (line: string) => void;
+    noteError?: (code: string) => void;
+}): Promise<void>;
 export declare const installCommand: Command;
-export declare function downloadFile(url: string, dest: string): Promise<{
-    sha256: string;
-}>;

package/dist/cli/commands/install.js

@@ -1,492 +1,42 @@
 import { Command } from "commander";
-import { execSync } from "child_process";
-import { createInterface } from "node:readline/promises";
-import { createHash } from "crypto";
-import { chmodSync, createWriteStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync, symlinkSync, } from "fs";
-import { pipeline } from "stream/promises";
-import { Readable } from "stream";
-import { tmpdir, platform } from "os";
-import { dirname, join, resolve } from "path";
-import { ENGINE_BINARY_ENV, LINUX_ENGINE_BINARY_NAME, macInstallDestination, recordEngineInstall, windowsEnginePaths, findExtractedEngineBinary, linuxArchiveKind, linuxEngineInstallDir, pickLinuxReleaseAsset, resolveLinuxInstallSource, } from "../../core/engine-install.js";
-const RELEASES_URL = "https://www.summerengine.com/api/desktop/releases";
-/** Guard a download URL from the releases endpoint. A missing/empty URL (an
- *  outdated or misconfigured endpoint) otherwise becomes a cryptic
- *  fetch(undefined) failure — surface it clearly with a manual fallback. */
-export function requireDownloadUrl(value, label) {
-    if (!value || value.trim().length === 0) {
-        throw new Error(`Release info is missing the ${label} download URL — the releases endpoint may be ` +
-            `outdated. Download manually from https://summerengine.com/download`);
-    }
-    return value;
-}
-/** Verify a downloaded file's sha256 against the expected hash from the releases
- *  endpoint. Skipped when no expected hash is published. Catches a truncated or
- *  corrupted download (a ~1GB install over a flaky network) before it becomes a
- *  confusing DMG-mount / installer failure downstream. */
-export function verifyChecksum(actual, expected, label) {
-    if (!expected || expected.trim().length === 0)
-        return; // nothing published to verify against
-    if (actual.toLowerCase() !== expected.toLowerCase()) {
-        throw new Error(`${label} checksum mismatch — the download was corrupted or incomplete ` +
-            `(expected ${expected.slice(0, 12)}…, got ${actual.slice(0, 12)}…). Re-run \`summer install\`.`);
-    }
-}
-// The bundle-version readers live in core (src/core/launch-posture.ts) because
-// `summer run` needs the installed version BEFORE the engine is up to decide
-// whether it may pass --summer-background; re-exported here for install.test.ts.
-import { parseMacBundleVersion, readMacBundleVersion } from "../../core/launch-posture.js";
-export { parseMacBundleVersion, readMacBundleVersion };
-export function isSameVersion(installed, latest) {
-    if (!installed)
-        return false;
-    const norm = (value) => value.trim().replace(/^v/i, "");
-    return norm(installed) === norm(latest);
-}
-/** Decide what `summer install` may do about an existing /Applications/Summer.app.
- *  Replacing an installed engine is destructive, so it needs --yes or a TTY
- *  prompt; an equal version is a no-op success. */
-export function planMacInstall(input) {
-    if (!input.exists)
-        return { action: "install" };
-    if (isSameVersion(input.installedVersion, input.latestVersion)) {
-        return { action: "up-to-date", version: input.latestVersion };
-    }
-    if (input.yes)
-        return { action: "install" };
-    if (input.isTTY)
-        return { action: "needs-confirmation", installed: input.installedVersion };
-    return {
-        action: "refuse",
-        reason: `Summer Engine ${input.installedVersion ?? "(unknown version)"} is already installed; ` +
-            `updating to v${input.latestVersion} replaces it. Re-run with --yes to confirm.`,
-    };
-}
-/** Replace destApp with the bundle on the mounted DMG WITHOUT a window where
- *  no engine exists: copy to <destApp>.new first, and only after that
- *  succeeds remove the old bundle and rename the staged copy into place. A
- *  failed copy leaves the existing install untouched. */
-export function replaceMacApp(mountPoint, destApp, exec) {
-    const staged = `${destApp}.new`;
-    exec(`rm -rf "${staged}"`);
-    try {
-        exec(`cp -R "${mountPoint}/Summer.app" "${staged}"`);
+import { noteCliError } from "../../core/cli-usage.js";
+import { EngineInstallError, asInstallError, errorDetail, installFailureReason } from "../../core/engine-install.js";
+import { installEngine } from "../../core/engine-installer.js";
+// The install itself lives in core (shared with `summer dev` and the MCP's
+// projects.open_local); this file is the command.
+export * from "../../core/engine-installer.js";
+// ------------------------------------------------------------------ command
+/** The coded failure an error from installEngine stands for, or null for a
+ *  bug (rethrown as before). A raw ENOSPC/EACCES/EPERM still gets its code. */
+export function installCommandFailure(err) {
+    if (err instanceof EngineInstallError)
+        return err;
+    const reason = installFailureReason(err, "copy");
+    return reason === "disk_space" || reason === "permission" ? asInstallError(err, reason, errorDetail) : null;
+}
+/** `summer install`: installEngine with a printed, coded failure and exit code 1. */
+export async function runInstallCommand(opts, deps = {}) {
+    try {
+        await (deps.install ?? installEngine)({
+            path: opts.path,
+            yes: opts.yes,
+            log: (line) => console.log(line),
+            isTTY: Boolean(process.stdin.isTTY),
+        });
     }
     catch (err) {
-        try {
-            exec(`rm -rf "${staged}"`);
-        }
-        catch { /* best effort */ }
-        throw err;
-    }
-    exec(`rm -rf "${destApp}"`);
-    exec(`mv "${staged}" "${destApp}"`);
-}
-/** Remove partial downloads / staged bundles when the user interrupts. */
-function cleanupOnSignal(paths) {
-    const handler = () => {
-        for (const path of paths) {
-            try {
-                rmSync(path, { recursive: true, force: true });
-            }
-            catch { /* best effort */ }
-        }
-        process.exit(130);
-    };
-    process.on("SIGINT", handler);
-    process.on("SIGTERM", handler);
-    return () => {
-        process.off("SIGINT", handler);
-        process.off("SIGTERM", handler);
-    };
-}
-async function confirm(question) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
-        return answer === "y" || answer === "yes";
-    }
-    finally {
-        rl.close();
+        const failure = installCommandFailure(err);
+        if (!failure)
+            throw err;
+        (deps.error ?? ((line) => console.error(line)))(failure.message);
+        (deps.noteError ?? noteCliError)(failure.reason);
+        process.exitCode = 1;
     }
 }
-/** Velopack Setup.exe install args. Velopack is NOT NSIS: silent install is
- *  `--silent` and a custom directory is `--installto <dir>` (per Velopack's
- *  setup.exe CLI). The old NSIS flags (/S, /D=) are rejected by the Velopack
- *  installer with "unexpected argument '/S' found" — this is the wizard bug. */
-export function windowsInstallerArgs(customPath) {
-    return customPath ? `--silent --installto "${customPath}"` : "--silent";
-}
-/** Printed after an install: the first start of a new engine is slow and silent. */
-export const FIRST_START_NOTE = "The first start of a new engine version can take several minutes with no output " +
-    "(the system checks the new app and the engine builds its caches). Later starts are fast.";
-/** Where the Velopack installer put Summer.exe: <dir>/current/Summer.exe for --path, else the default locations. */
-export function windowsInstalledBinary(customPath, exists = existsSync) {
-    const candidates = customPath
-        ? [join(customPath, "current", "Summer.exe"), join(customPath, "Summer.exe")]
-        : windowsEnginePaths();
-    return candidates.find((path) => exists(path)) ?? null;
-}
-/**
- * Download progress: rewrites one line on a terminal; elsewhere (an agent,
- * a log file) one line per 10%, so a 1 GB download is about ten lines
- * instead of hundreds of kilobytes.
- */
-export function createProgressReporter(isTTY, write) {
-    let lastStep = -1;
-    return (downloaded, total) => {
-        if (total <= 0)
-            return;
-        const pct = Math.min(100, Math.floor((downloaded / total) * 100));
-        const mb = (downloaded / 1024 / 1024).toFixed(1);
-        if (isTTY) {
-            write(`\r  ${pct}% (${mb}MB)`);
-            return;
-        }
-        const step = Math.floor(pct / 10);
-        if (step > lastStep) {
-            lastStep = step;
-            write(`  ${pct}% (${mb}MB)\n`);
-        }
-    };
-}
 export const installCommand = new Command("install")
     .description("Download and install Summer Engine")
     .option("--path <dir>", "Custom install directory (macOS: the engine goes in <dir>/Summer.app). summer remembers it, so later commands find this engine")
     .option("--yes", "Replace an already-installed engine without prompting")
     .action(async (opts) => {
-    const os = platform();
-    if (os === "linux") {
-        await installLinux(opts.path);
-        return;
-    }
-    if (os !== "darwin" && os !== "win32") {
-        console.error(`Unsupported platform: ${os}.\n` +
-            "Summer Engine installs on macOS, Windows, and Linux (x86_64).\n" +
-            "Download from: https://summerengine.com/download");
-        process.exit(1);
-    }
-    console.log("Fetching latest release info...");
-    let releases;
-    try {
-        const res = await fetch(RELEASES_URL, { signal: AbortSignal.timeout(10000) });
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status}`);
-        releases = (await res.json());
-    }
-    catch (err) {
-        console.error("Could not fetch release info. Download manually from:\n" +
-            "  https://summerengine.com/download");
-        process.exit(1);
-    }
-    if (os === "darwin") {
-        await installMac(releases, opts.path, Boolean(opts.yes));
-    }
-    else {
-        await installWindows(releases, opts.path);
-    }
+    await runInstallCommand(opts);
 });
-async function installMac(releases, customPath, yes = false) {
-    const info = releases.latest.macos;
-    if (!info) {
-        console.error("No macOS release found.");
-        process.exit(1);
-    }
-    const dmgUrl = requireDownloadUrl(info.dmg_url, "macOS DMG");
-    console.log(`Latest version: ${info.version}`);
-    const destApp = macInstallDestination(customPath);
-    const destBinary = join(destApp, "Contents", "MacOS", "Summer");
-    const exists = existsSync(destApp);
-    const installedVersion = exists ? readMacBundleVersion(destApp) : null;
-    const plan = planMacInstall({
-        exists,
-        installedVersion,
-        latestVersion: info.version,
-        yes,
-        isTTY: Boolean(process.stdin.isTTY),
-    });
-    if (plan.action === "up-to-date") {
-        await recordEngineInstall(destBinary, plan.version);
-        console.log(`Summer Engine v${plan.version} is already installed at ${destApp} (up to date).`);
-        return;
-    }
-    if (plan.action === "refuse") {
-        console.error(plan.reason);
-        process.exitCode = 1;
-        return;
-    }
-    if (plan.action === "needs-confirmation") {
-        console.log(`Summer Engine ${plan.installed ?? "(unknown version)"} is installed at ${destApp}.`);
-        if (!(await confirm(`Replace it with v${info.version}?`))) {
-            console.log("Cancelled. Nothing was changed.");
-            return;
-        }
-    }
-    const dmgPath = join(tmpdir(), `Summer-v${info.version}.dmg`);
-    const stagedApp = `${destApp}.new`;
-    const releaseSignals = cleanupOnSignal([dmgPath, stagedApp]);
-    console.log(`Downloading Summer Engine v${info.version} (~1 GB, includes bundled Git + runtime)...`);
-    try {
-        const { sha256 } = await downloadFile(dmgUrl, dmgPath);
-        verifyChecksum(sha256, info.dmg_sha256, "DMG");
-    }
-    catch (err) {
-        releaseSignals();
-        try {
-            execSync(`rm -f "${dmgPath}"`, { stdio: "ignore" });
-        }
-        catch { /* best effort */ }
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    console.log("Mounting DMG...");
-    const mountOutput = execSync(`hdiutil attach "${dmgPath}" -nobrowse -noverify -noautoopen`, {
-        encoding: "utf-8",
-    });
-    const mountPoint = mountOutput
-        .split("\n")
-        .filter((line) => line.includes("/Volumes/"))
-        .map((line) => line.trim().split("\t").pop()?.trim())
-        .find(Boolean);
-    if (!mountPoint) {
-        console.error("Failed to find mount point. Install manually from the DMG.");
-        process.exit(1);
-    }
-    try {
-        console.log("Installing to " + destApp + "...");
-        mkdirSync(dirname(destApp), { recursive: true });
-        replaceMacApp(mountPoint, destApp, (command) => execSync(command, { stdio: "ignore" }));
-        console.log("Done!");
-    }
-    catch (err) {
-        console.error(`Install failed: ${err instanceof Error ? err.message : String(err)}\n` +
-            (exists ? `The existing ${destApp} was left in place.` : "Nothing was installed."));
-        process.exitCode = 1;
-        return;
-    }
-    finally {
-        execSync(`hdiutil detach "${mountPoint}" -quiet`, { stdio: "ignore" });
-        try {
-            execSync(`rm "${dmgPath}"`, { stdio: "ignore" });
-        }
-        catch { }
-        releaseSignals();
-    }
-    await recordEngineInstall(destBinary, info.version);
-    console.log(`\nSummer Engine v${info.version} installed to ${destApp}`);
-    console.log(FIRST_START_NOTE);
-    console.log("\nNext steps:");
-    console.log("  summer login    # Sign in to your account");
-    console.log("  summer run      # Launch the engine");
-}
-async function installWindows(releases, customPath) {
-    const info = releases.latest.windows;
-    if (!info) {
-        console.error("No Windows release found.");
-        process.exit(1);
-    }
-    const exeUrl = requireDownloadUrl(info.url, "Windows installer");
-    console.log(`Latest version: ${info.version}`);
-    const exePath = join(tmpdir(), `Summer-v${info.version}.exe`);
-    console.log(`Downloading Summer Engine v${info.version} (~1 GB, includes bundled Git + runtime)...`);
-    try {
-        const { sha256 } = await downloadFile(exeUrl, exePath);
-        verifyChecksum(sha256, info.sha256, "installer");
-    }
-    catch (err) {
-        try {
-            execSync(`del "${exePath}"`, { stdio: "ignore" });
-        }
-        catch { /* best effort */ }
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    console.log("Running installer...");
-    try {
-        execSync(`"${exePath}" ${windowsInstallerArgs(customPath)}`, {
-            stdio: "inherit",
-        });
-    }
-    catch {
-        console.error("Installer failed. Try running it manually:\n  " + exePath);
-        process.exit(1);
-    }
-    try {
-        execSync(`del "${exePath}"`, { stdio: "ignore" });
-    }
-    catch { }
-    const installed = windowsInstalledBinary(customPath);
-    if (installed)
-        await recordEngineInstall(installed, info.version);
-    console.log(`\nSummer Engine v${info.version} installed${installed ? ` to ${installed}` : "!"}`);
-    console.log(FIRST_START_NOTE);
-    console.log("\nNext steps:");
-    console.log("  summer login    # Sign in to your account");
-    console.log("  summer run      # Launch the engine");
-}
-// ------------------------------------------------------------------- Linux
-// Source resolution, release picking, and archive detection live in
-// core/engine-install.ts; this section is the process I/O around them.
-function walkFiles(dir) {
-    const out = [];
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        const path = join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...walkFiles(path));
-        else if (entry.isFile())
-            out.push(path);
-    }
-    return out;
-}
-/** Register an existing binary the same way a download install does: the
- *  canonical ~/.summer/engine/summer-linux-x86_64 path points at it, so
- *  `summer run`/`summer doctor` find it even when the env var is not set. */
-function registerExistingLinuxBinary(sourcePath, destDir, destBinary) {
-    const absolute = resolve(sourcePath);
-    if (!existsSync(absolute)) {
-        console.error(`${ENGINE_BINARY_ENV} points at ${absolute}, but nothing exists there.`);
-        process.exit(1);
-    }
-    try {
-        chmodSync(absolute, 0o755);
-    }
-    catch {
-        // Best effort — a read-only mount still works if already executable.
-    }
-    mkdirSync(destDir, { recursive: true });
-    if (absolute !== destBinary) {
-        rmSync(destBinary, { force: true });
-        symlinkSync(absolute, destBinary);
-    }
-    console.log(`Registered existing engine binary: ${absolute}`);
-    console.log(`  -> ${destBinary}`);
-}
-async function fetchLinuxReleaseAsset(apiUrl) {
-    const res = await fetch(apiUrl, {
-        headers: { Accept: "application/vnd.github+json" },
-        signal: AbortSignal.timeout(15000),
-    });
-    if (!res.ok)
-        throw new Error(`HTTP ${res.status}`);
-    return pickLinuxReleaseAsset(await res.json());
-}
-async function installLinux(customPath) {
-    if (process.arch !== "x64") {
-        console.error(`Linux ${process.arch} has no published Summer Engine artifact yet (x86_64 only).\n` +
-            `Build from source, then set ${ENGINE_BINARY_ENV} to the binary and re-run \`summer install\`.`);
-        process.exit(1);
-    }
-    const destDir = customPath ? resolve(customPath) : linuxEngineInstallDir();
-    const destBinary = join(destDir, LINUX_ENGINE_BINARY_NAME);
-    const source = resolveLinuxInstallSource();
-    if (source.kind === "binary") {
-        registerExistingLinuxBinary(source.path, destDir, destBinary);
-        await recordEngineInstall(destBinary, null);
-        printLinuxNextSteps(destBinary);
-        return;
-    }
-    let url = source.kind === "url" ? source.url : "";
-    let sha256Url;
-    let versionLabel = "custom";
-    if (source.kind === "release") {
-        console.log("Fetching latest Linux release info...");
-        try {
-            const asset = await fetchLinuxReleaseAsset(source.apiUrl);
-            url = asset.url;
-            sha256Url = asset.sha256Url;
-            versionLabel = asset.version;
-        }
-        catch (err) {
-            console.error(`Could not resolve a Linux release artifact: ${err instanceof Error ? err.message : String(err)}`);
-            process.exit(1);
-        }
-        console.log(`Latest Linux release: ${versionLabel}`);
-    }
-    const kind = linuxArchiveKind(url);
-    const downloadPath = join(tmpdir(), `summer-engine-${Date.now()}.${kind === "binary" ? "bin" : kind === "zip" ? "zip" : "tar.gz"}`);
-    console.log(`Downloading ${url} ...`);
-    try {
-        const { sha256 } = await downloadFile(url, downloadPath);
-        if (sha256Url) {
-            const shaRes = await fetch(sha256Url, { signal: AbortSignal.timeout(15000) });
-            if (shaRes.ok) {
-                const expected = (await shaRes.text()).trim().split(/\s+/, 1)[0];
-                verifyChecksum(sha256, expected, "Linux artifact");
-            }
-        }
-        mkdirSync(destDir, { recursive: true });
-        let extractedBinary = downloadPath;
-        let extractDir = null;
-        if (kind !== "binary") {
-            extractDir = join(tmpdir(), `summer-engine-extract-${Date.now()}`);
-            mkdirSync(extractDir, { recursive: true });
-            if (kind === "tar.gz") {
-                execSync(`tar -xzf "${downloadPath}" -C "${extractDir}"`, { stdio: "ignore" });
-            }
-            else {
-                execSync(`unzip -oq "${downloadPath}" -d "${extractDir}"`, { stdio: "ignore" });
-            }
-            const found = findExtractedEngineBinary(walkFiles(extractDir));
-            if (!found) {
-                throw new Error(`The downloaded archive contains no engine binary (expected ${LINUX_ENGINE_BINARY_NAME}).`);
-            }
-            extractedBinary = found;
-        }
-        // Replace, never edit in place: an engine reading its own binary mid-write
-        // is worse than a moment with no file. rename first (same tmpfs), copy as
-        // the cross-device fallback.
-        rmSync(destBinary, { force: true });
-        try {
-            renameSync(extractedBinary, destBinary);
-        }
-        catch {
-            execSync(`cp "${extractedBinary}" "${destBinary}"`, { stdio: "ignore" });
-        }
-        chmodSync(destBinary, 0o755);
-        if (extractDir)
-            rmSync(extractDir, { recursive: true, force: true });
-    }
-    catch (err) {
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-    finally {
-        rmSync(downloadPath, { force: true });
-    }
-    await recordEngineInstall(destBinary, versionLabel === "custom" ? null : versionLabel);
-    console.log(`\nSummer Engine (${versionLabel}) installed to ${destBinary}`);
-    console.log(FIRST_START_NOTE);
-    printLinuxNextSteps(destBinary);
-}
-function printLinuxNextSteps(binary) {
-    console.log("\nNext steps:");
-    console.log("  summer doctor   # Verify the setup");
-    console.log(`  ${binary} --headless --editor --path <project>   # Headless engine`);
-    console.log("  summer login    # Optional: only gateway features (asset search/generation) need it");
-}
-export async function downloadFile(url, dest) {
-    const res = await fetch(url);
-    if (!res.ok || !res.body) {
-        throw new Error(`Download failed: HTTP ${res.status}`);
-    }
-    const dir = join(dest, "..");
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const fileStream = createWriteStream(dest);
-    const readable = Readable.fromWeb(res.body);
-    // Hash while streaming (the 'data' listener and the pipe both see every chunk
-    // in flowing mode), so we get integrity for free without a second read pass.
-    const hash = createHash("sha256");
-    let downloaded = 0;
-    const total = parseInt(res.headers.get("content-length") || "0", 10);
-    const isTTY = Boolean(process.stdout.isTTY);
-    const report = createProgressReporter(isTTY, (text) => process.stdout.write(text));
-    readable.on("data", (chunk) => {
-        hash.update(chunk);
-        downloaded += chunk.length;
-        report(downloaded, total);
-    });
-    await pipeline(readable, fileStream);
-    if (isTTY)
-        process.stdout.write("\n");
-    return { sha256: hash.digest("hex") };
-}

package/dist/cli/commands/login.js

@@ -15,7 +15,7 @@ const POLL_TIMEOUT_MS = 900000;
 const HEARTBEAT_MS = 30000;
 export const loginCommand = new Command("login")
     .description("Sign in to Summer in your browser: your Summer account, then the store, publishing and Grow tools in the same browser")
-    .option("--store", "Only the store sign-in (summer_publish_build, the store, publishing, board and Grow tools); plain summer login does it too")
+    .option("--store", "Only the store sign-in (uploads with store.upload_file, item sync with economy.sync_items, the store, publishing, board and Grow tools); plain summer login does it too")
     .option("--no-store", "Only the Summer account sign-in; skip the store sign-in")
     .option("--force", "Force re-authentication even if already logged in")
     .action(async (opts) => {

package/dist/cli/commands/ops.d.ts

@@ -39,7 +39,6 @@ export interface OpsCliDeps {
     files?: FileSaver;
 }
 export declare const defaultOpsCliDeps: OpsCliDeps;
-/** The answer for a person; `out` is the --out to keep in the printed wait command. */
 export declare function formatAnswer(answer: Answer, out?: string): string;
 /** Run one operation from the command line and print its answer; returns the exit code. */
 export declare function runOpFromCli(op: string, argv: readonly string[], deps?: OpsCliDeps): Promise<number>;
@@ -61,4 +60,21 @@ export declare function searchFromCli(query: string, options: {
 export declare function describeFromCli(op: string, deps?: OpsCliDeps, options?: {
     json?: boolean;
 }): Promise<number>;
+/** `summer <area> --help`: the area's actions, from this package and the shipped catalog (no network). */
+export declare function areaHelp(area: string): string;
+type WireOperation = {
+    name: string;
+    title?: string;
+    summary?: string;
+    effect?: string;
+    approval?: string;
+    auth?: string;
+    input?: JsonSchema & {
+        required?: string[];
+    };
+};
+/** One operation's help: its command, what it does, who approves, the sign-in and each field as a flag. */
+export declare function operationHelp(operation: WireOperation): string;
+/** `summer <area> <action> --help`: from this package or the shipped catalog; the server only for an operation newer than both. */
+export declare function operationHelpFromCli(op: string, deps?: OpsCliDeps): Promise<number>;
 export declare function opsCliCommands(): Command[];