@gadgetinc/ggt 0.4.10 → 1.0.1

package/lib/services/filesync/filesync.js

@@ -1,7 +1,5 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import dayjs from "dayjs";
 import { execa } from "execa";
-import { findUp } from "find-up";
 import fs from "fs-extra";
 import ms from "ms";
 import assert from "node:assert";
@@ -10,159 +8,178 @@ import process from "node:process";
 import pMap from "p-map";
 import PQueue from "p-queue";
 import pRetry from "p-retry";
-import { z } from "zod";
+import pluralize from "pluralize";
 import { FileSyncEncoding } from "../../__generated__/graphql.js";
-import { getApps } from "../app/app.js";
-import { AppArg } from "../app/arg.js";
-import { Edit } from "../app/edit/edit.js";
-import { EditError } from "../app/edit/error.js";
 import { FILE_SYNC_COMPARISON_HASHES_QUERY, FILE_SYNC_FILES_QUERY, FILE_SYNC_HASHES_QUERY, PUBLISH_FILE_SYNC_EVENTS_MUTATION, REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION } from "../app/edit/operation.js";
-import { ArgError } from "../command/arg.js";
-import { config, homePath } from "../config/config.js";
-import { select } from "../output/prompt.js";
-import { sprint } from "../output/sprint.js";
-import { getUserOrLogin } from "../user/user.js";
-import { sortBySimilar } from "../util/collection.js";
+import { config } from "../config/config.js";
+import { confirm } from "../output/confirm.js";
+import { println } from "../output/print.js";
+import { filesyncProblemsToProblems, sprintProblems } from "../output/problems.js";
+import { EdgeCaseError } from "../output/report.js";
+import { select } from "../output/select.js";
+import { spin } from "../output/spinner.js";
+import { sprint, sprintln } from "../output/sprint.js";
+import { symbol } from "../output/symbols.js";
+import { ts } from "../output/timestamp.js";
 import { noop } from "../util/function.js";
-import { isGraphQLErrors, isGraphQLResult, isObject, isString } from "../util/is.js";
-import { Changes, printChanges } from "./changes.js";
+import { isEEXISTError, isENOENTError, isENOTDIRError, isENOTEMPTYError } from "../util/is.js";
+import { serializeError } from "../util/object.js";
+import { Changes, printChanges, sprintChanges } from "./changes.js";
 import { getConflicts, printConflicts, withoutConflictingChanges } from "./conflicts.js";
-import { Directory, supportsPermissions, swallowEnoent } from "./directory.js";
-import { InvalidSyncFileError, TooManySyncAttemptsError } from "./error.js";
-import { getChanges, isEqualHashes } from "./hashes.js";
+import { supportsPermissions, swallowEnoent } from "./directory.js";
+import { TooManyMergeAttemptsError, isFilesVersionMismatchError, swallowFilesVersionMismatch } from "./error.js";
+import { getNecessaryChanges, isEqualHashes } from "./hashes.js";
+import { MergeConflictPreference } from "./strategy.js";
+/**
+ * The maximum attempts to automatically merge local and environment
+ * file changes when a FilesVersionMismatchError is encountered before
+ * throwing a {@linkcode TooManyMergeAttemptsError}.
+ */ export const MAX_MERGE_ATTEMPTS = 10;
+/**
+ * The maximum length of file content that can be pushed to Gadget in a
+ * single request.
+ */ export const MAX_PUSH_CONTENT_LENGTH = 50 * 1024 * 1024; // 50mb
 export class FileSync {
-    /**
-   * The last filesVersion that was written to the filesystem.
-   *
-   * This determines if the filesystem in Gadget is ahead of the
-   * filesystem on the local machine.
-   */ get filesVersion() {
-        return BigInt(this._syncJson.filesVersion);
-    }
-    /**
-   * The largest mtime that was seen on the filesystem.
-   *
-   * This is used to determine if any files have changed since the last
-   * sync. This does not include the mtime of files that are ignored.
-   */ get mtime() {
-        return this._syncJson.mtime;
-    }
-    /**
-   * Initializes a {@linkcode FileSync} instance.
-   * - Ensures the directory exists.
-   * - Ensures the directory is empty or contains a `.gadget/sync.json` file (unless `options.force` is `true`)
-   * - Ensures an app is specified (either via `options.app` or by prompting the user)
-   * - Ensures the specified app matches the app the directory was previously synced to (unless `options.force` is `true`)
-   */ static async init(ctx) {
-        ctx = ctx.child({
-            name: "filesync"
-        });
-        const user = await getUserOrLogin(ctx);
-        const apps = await getApps(ctx);
-        if (apps.length === 0) {
-            throw new ArgError(sprint`
-          You (${user.email}) don't have have any Gadget applications.
-
-          Visit https://gadget.new to create one!
-      `);
-        }
-        let dir = ctx.args._[0];
-        if (!dir) {
-            // the user didn't specify a directory
-            const filepath = await findUp(".gadget/sync.json");
-            if (filepath) {
-                // we found a .gadget/sync.json file, use its parent directory
-                dir = path.join(filepath, "../..");
+    async hashes(ctx) {
+        const spinner = spin({
+            ensureEmptyLineAbove: true
+        })`
+      Calculating file changes.
+    `;
+        try {
+            const [localHashes, { localFilesVersionHashes, environmentHashes, environmentFilesVersion }] = await Promise.all([
+                // get the hashes of our local files
+                this.syncJson.directory.hashes(),
+                // get the hashes of our local filesVersion and the latest filesVersion
+                (async ()=>{
+                    let localFilesVersionHashes;
+                    let environmentHashes;
+                    let environmentFilesVersion;
+                    if (this.syncJson.filesVersion === 0n) {
+                        // we're either syncing for the first time or we're syncing a
+                        // non-empty directory without a `.gadget/sync.json` file,
+                        // regardless get the hashes of the latest filesVersion
+                        const { fileSyncHashes } = await this.syncJson.edit.query({
+                            query: FILE_SYNC_HASHES_QUERY
+                        });
+                        environmentFilesVersion = BigInt(fileSyncHashes.filesVersion);
+                        environmentHashes = fileSyncHashes.hashes;
+                        localFilesVersionHashes = {}; // represents an empty directory
+                    } else {
+                        // this isn't the first time we're syncing, so get the
+                        // hashes of the files at our local filesVersion and the
+                        // latest filesVersion
+                        const { fileSyncComparisonHashes } = await this.syncJson.edit.query({
+                            query: FILE_SYNC_COMPARISON_HASHES_QUERY,
+                            variables: {
+                                filesVersion: String(this.syncJson.filesVersion)
+                            }
+                        });
+                        localFilesVersionHashes = fileSyncComparisonHashes.filesVersionHashes.hashes;
+                        environmentHashes = fileSyncComparisonHashes.latestFilesVersionHashes.hashes;
+                        environmentFilesVersion = BigInt(fileSyncComparisonHashes.latestFilesVersionHashes.filesVersion);
+                    }
+                    return {
+                        localFilesVersionHashes,
+                        environmentHashes,
+                        environmentFilesVersion
+                    };
+                })()
+            ]);
+            const inSync = isEqualHashes(ctx, localHashes, environmentHashes);
+            const localChanges = getNecessaryChanges(ctx, {
+                from: localFilesVersionHashes,
+                to: localHashes,
+                existing: environmentHashes,
+                ignore: [
+                    ".gadget/"
+                ]
+            });
+            let environmentChanges = getNecessaryChanges(ctx, {
+                from: localFilesVersionHashes,
+                to: environmentHashes,
+                existing: localHashes
+            });
+            if (!inSync && localChanges.size === 0 && environmentChanges.size === 0) {
+                // we're not in sync, but neither the local filesystem nor the
+                // environment's filesystem have any changes; this is only
+                // possible if the local filesystem has modified .gadget/ files
+                environmentChanges = getNecessaryChanges(ctx, {
+                    from: localHashes,
+                    to: environmentHashes
+                });
+                assert(environmentChanges.size > 0, "expected environmentChanges to have changes");
+                assert(Array.from(environmentChanges.keys()).every((path)=>path.startsWith(".gadget/")), "expected all environmentChanges to be .gadget/ files");
+            }
+            assert(inSync || localChanges.size > 0 || environmentChanges.size > 0, "there must be changes if hashes don't match");
+            const localChangesToPush = getNecessaryChanges(ctx, {
+                from: environmentHashes,
+                to: localHashes,
+                ignore: [
+                    ".gadget/"
+                ]
+            });
+            const environmentChangesToPull = getNecessaryChanges(ctx, {
+                from: localHashes,
+                to: environmentHashes
+            });
+            const onlyDotGadgetFilesChanged = Array.from(environmentChangesToPull.keys()).every((filepath)=>filepath.startsWith(".gadget/"));
+            const bothChanged = localChanges.size > 0 && environmentChanges.size > 0 && !onlyDotGadgetFilesChanged;
+            if (inSync) {
+                spinner.succeed`Your files are up to date. ${ts()}`;
             } else {
-                // we didn't find a .gadget/sync.json file, use the current directory
-                dir = process.cwd();
+                spinner.succeed`Calculated file changes. ${ts()}`;
             }
+            return {
+                inSync,
+                localFilesVersionHashes,
+                localHashes,
+                localChanges,
+                localChangesToPush,
+                environmentHashes,
+                environmentChanges,
+                environmentChangesToPull,
+                environmentFilesVersion,
+                onlyDotGadgetFilesChanged,
+                bothChanged
+            };
+        } catch (error) {
+            spinner.fail();
+            throw error;
         }
-        if (config.windows && dir.startsWith("~/")) {
-            // `~` doesn't expand to the home directory on Windows
-            dir = homePath(dir.slice(2));
+    }
+    async print(ctx, { hashes } = {}) {
+        const { inSync, localChanges, environmentChanges, onlyDotGadgetFilesChanged, bothChanged } = hashes ?? await this.hashes(ctx);
+        if (inSync) {
+            // the spinner in hashes will have already printed that we're in sync
+            return;
         }
-        // ensure the root directory is an absolute path and exists
-        const wasEmptyOrNonExistent = await isEmptyOrNonExistentDir(dir);
-        await fs.ensureDir(dir = path.resolve(dir));
-        // try to load the .gadget/sync.json file
-        const state = await fs.readJson(path.join(dir, ".gadget/sync.json")).then((json)=>z.object({
-                app: z.string(),
-                filesVersion: z.string(),
-                mtime: z.number()
-            }).parse(json)).catch(noop);
-        let appSlug = ctx.args["--app"] || state?.app;
-        if (!appSlug) {
-            // the user didn't specify an app, suggest some apps that they can sync to
-            appSlug = await select(ctx, {
-                message: "Select the app to sync to",
-                choices: apps.map((x)=>x.slug)
+        if (localChanges.size > 0) {
+            printChanges(ctx, {
+                changes: localChanges,
+                tense: "past",
+                title: sprint`Your local files {underline have} changed.`
             });
+        } else {
+            println({
+                ensureEmptyLineAbove: true
+            })`
+        Your local files {underline have not} changed.
+      `;
         }
-        // try to find the appSlug in their list of apps
-        const app = apps.find((app)=>app.slug === appSlug);
-        if (!app) {
-            // the specified appSlug doesn't exist in their list of apps,
-            // either they misspelled it or they don't have access to it
-            // anymore, suggest some apps that are similar to the one they
-            // specified
-            const similarAppSlugs = sortBySimilar(appSlug, apps.map((app)=>app.slug)).slice(0, 5);
-            throw new ArgError(sprint`
-        Unknown application:
-
-          ${appSlug}
-
-        Did you mean one of these?
-
-
-      `.concat(`  • ${similarAppSlugs.join("\n  • ")}`));
-        }
-        ctx.app = app;
-        const directory = await Directory.init(dir);
-        if (!state) {
-            // the .gadget/sync.json file didn't exist or contained invalid json
-            if (wasEmptyOrNonExistent || ctx.args["--force"]) {
-                // the directory was empty or the user passed --force
-                // either way, create a fresh .gadget/sync.json file
-                return new FileSync(ctx, directory, app, {
-                    app: app.slug,
-                    filesVersion: "0",
-                    mtime: 0
-                });
-            }
-            // the directory isn't empty and the user didn't pass --force
-            throw new InvalidSyncFileError(dir, app.slug);
-        }
-        // the .gadget/sync.json file exists
-        if (state.app === app.slug) {
-            // the .gadget/sync.json file is for the same app that the user specified
-            return new FileSync(ctx, directory, app, state);
-        }
-        // the .gadget/sync.json file is for a different app
-        if (ctx.args["--force"]) {
-            // the user passed --force, so use the app they specified and overwrite everything
-            return new FileSync(ctx, directory, app, {
-                app: app.slug,
-                filesVersion: "0",
-                mtime: 0
+        if (environmentChanges.size > 0 && !onlyDotGadgetFilesChanged) {
+            printChanges(ctx, {
+                changes: environmentChanges,
+                tense: "past",
+                title: sprint`Your environment's files {underline have}${bothChanged ? " also" : ""} changed.`
             });
+        } else {
+            println({
+                ensureEmptyLineAbove: true
+            })`
+        Your environment's files {underline have not} changed.
+      `;
         }
-        // the user didn't pass --force, so throw an error
-        throw new ArgError(sprint`
-        You were about to sync the following app to the following directory:
-
-          {dim ${app.slug}} → {dim ${dir}}
-
-        However, that directory has already been synced with this app:
-
-          {dim ${state.app}}
-
-        If you're sure that you want to sync:
-
-          {dim ${app.slug}} → {dim ${dir}}
-
-        Then run {dim ggt sync} again with the {dim --force} flag.
-      `);
     }
     /**
    * Waits for all pending and ongoing filesync operations to complete.
@@ -170,23 +187,31 @@ export class FileSync {
         await this._syncOperations.onIdle();
     }
     /**
-   * Sends file changes to the Gadget.
+   * Attempts to send file changes to the Gadget. If a files version
+   * mismatch error occurs, this function will merge the changes with
+   * Gadget instead.
    *
+   * @param ctx - The context to use.
    * @param options - The options to use.
    * @param options.changes - The changes to send.
+   * @param options.printLocalChangesOptions - The options to use when printing the local changes.
+   * @param options.printEnvironmentChangesOptions - The options to use when printing the changes from Gadget.
    * @returns A promise that resolves when the changes have been sent.
-   */ async sendChangesToGadget({ changes }) {
+   */ async mergeChangesWithEnvironment(ctx, { changes, printLocalChangesOptions, printEnvironmentChangesOptions }) {
         await this._syncOperations.add(async ()=>{
             try {
-                await this._sendChangesToGadget({
-                    changes
+                await this._sendChangesToEnvironment(ctx, {
+                    changes,
+                    printLocalChangesOptions
                 });
             } catch (error) {
-                swallowFilesVersionMismatch(this.ctx, error);
+                swallowFilesVersionMismatch(ctx, error);
                 // we either sent the wrong expectedFilesVersion or we received
                 // a filesVersion that is greater than the expectedFilesVersion
                 // + 1, so we need to stop what we're doing and get in sync
-                await this.sync();
+                await this.merge(ctx, {
+                    printEnvironmentChangesOptions
+                });
             }
         });
     }
@@ -194,13 +219,15 @@ export class FileSync {
    * Subscribes to file changes on Gadget and executes the provided
    * callbacks before and after the changes occur.
    *
+   * @param ctx - The context to use.
    * @param options - The options to use.
    * @param options.beforeChanges - A callback that is called before the changes occur.
    * @param options.afterChanges - A callback that is called after the changes occur.
    * @param options.onError - A callback that is called if an error occurs.
+   * @param options.printEnvironmentChangesOptions - The options to use when printing the changes from Gadget.
    * @returns A function that unsubscribes from changes on Gadget.
-   */ subscribeToGadgetChanges({ beforeChanges = noop, afterChanges = noop, onError }) {
-        return this.edit.subscribe({
+   */ subscribeToEnvironmentChanges(ctx, { beforeChanges = noop, printEnvironmentChangesOptions, afterChanges = noop, onError }) {
+        return this.syncJson.edit.subscribe({
             subscription: REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION,
             // the reason this is a function rather than a static value is
             // so that it will be re-evaluated if the connection is lost and
@@ -208,26 +235,26 @@ export class FileSync {
             // filesVersion rather than the one that was sent when we first
             // subscribed
             variables: ()=>({
-                    localFilesVersion: String(this.filesVersion)
+                    localFilesVersion: String(this.syncJson.filesVersion)
                 }),
             onError,
             onData: ({ remoteFileSyncEvents: { changed, deleted, remoteFilesVersion } })=>{
                 this._syncOperations.add(async ()=>{
-                    if (BigInt(remoteFilesVersion) < this.filesVersion) {
-                        this.ctx.log.warn("skipping received changes because files version is outdated", {
+                    if (BigInt(remoteFilesVersion) < this.syncJson.filesVersion) {
+                        ctx.log.warn("skipping received changes because files version is outdated", {
                             filesVersion: remoteFilesVersion
                         });
                         return;
                     }
-                    this.ctx.log.debug("received files", {
+                    ctx.log.debug("received files", {
                         remoteFilesVersion,
                         changed: changed.map((change)=>change.path),
                         deleted: deleted.map((change)=>change.path)
                     });
                     const filterIgnoredFiles = (file)=>{
-                        const ignored = this.directory.ignores(file.path);
+                        const ignored = this.syncJson.directory.ignores(file.path);
                         if (ignored) {
-                            this.ctx.log.warn("skipping received change because file is ignored", {
+                            ctx.log.warn("skipping received change because file is ignored", {
                                 path: file.path
                             });
                         }
@@ -236,26 +263,25 @@ export class FileSync {
                     changed = changed.filter(filterIgnoredFiles);
                     deleted = deleted.filter(filterIgnoredFiles);
                     if (changed.length === 0 && deleted.length === 0) {
-                        await this._save(remoteFilesVersion);
+                        await this.syncJson.save(remoteFilesVersion);
                         return;
                     }
                     await beforeChanges({
                         changed: changed.map((file)=>file.path),
                         deleted: deleted.map((file)=>file.path)
                     });
-                    const changes = await this._writeToLocalFilesystem({
+                    const changes = await this._writeToLocalFilesystem(ctx, {
                         filesVersion: remoteFilesVersion,
                         files: changed,
-                        delete: deleted.map((file)=>file.path)
-                    });
-                    if (changes.size > 0) {
-                        printChanges(this.ctx, {
-                            message: sprint`← Received {gray ${dayjs().format("hh:mm:ss A")}}`,
-                            changes,
+                        delete: deleted.map((file)=>file.path),
+                        printEnvironmentChangesOptions: {
                             tense: "past",
-                            limit: 10
-                        });
-                    }
+                            ensureEmptyLineAbove: true,
+                            title: sprintln`{green ${symbol.tick}} Pulled ${pluralize("file", changed.length + deleted.length)}. ${symbol.arrowLeft} ${ts()}`,
+                            limit: 5,
+                            ...printEnvironmentChangesOptions
+                        }
+                    });
                     await afterChanges({
                         changes
                     });
@@ -268,95 +294,131 @@ export class FileSync {
    * - All non-conflicting changes are automatically merged.
    * - Conflicts are resolved by prompting the user to either keep their local changes or keep Gadget's changes.
    * - This function will not return until the filesystem is in sync.
-   */ async sync({ maxAttempts = 10 } = {}) {
+   */ async merge(ctx, { hashes, maxAttempts = 10, printLocalChangesOptions, printEnvironmentChangesOptions } = {}) {
         let attempt = 0;
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, no-constant-condition
-        while(true){
-            const { inSync, ...hashes } = await this.hashes();
-            if (inSync) {
+        do {
+            if (attempt === 0) {
+                hashes ??= await this.hashes(ctx);
+            } else {
+                hashes = await this.hashes(ctx);
+            }
+            if (hashes.inSync) {
                 this._syncOperations.clear();
-                this.ctx.log.info("filesystem is in sync", {
-                    attempt
-                });
-                await this._save(hashes.gadgetFilesVersion);
+                ctx.log.info("filesystem in sync");
+                await this.syncJson.save(hashes.environmentFilesVersion);
                 return;
             }
-            if (attempt++ >= maxAttempts) {
-                throw new TooManySyncAttemptsError(maxAttempts);
-            }
+            attempt += 1;
+            ctx.log.info("merging", {
+                attempt,
+                ...hashes
+            });
             try {
-                this.ctx.log.info("syncing", {
-                    attempt,
-                    ...hashes
+                await this._merge(ctx, {
+                    hashes,
+                    printLocalChangesOptions,
+                    printEnvironmentChangesOptions
                 });
-                await this._sync(hashes);
             } catch (error) {
-                swallowFilesVersionMismatch(this.ctx, error);
+                swallowFilesVersionMismatch(ctx, error);
             // we either sent the wrong expectedFilesVersion or we received
             // a filesVersion that is greater than the expectedFilesVersion
             // + 1, so try again
             }
-        }
+        }while (attempt < maxAttempts)
+        throw new TooManyMergeAttemptsError(maxAttempts);
     }
-    async _sync({ filesVersionHashes, localHashes, gadgetHashes, gadgetFilesVersion }) {
-        let localChanges = getChanges(this.ctx, {
-            from: filesVersionHashes,
-            to: localHashes,
-            existing: gadgetHashes,
-            ignore: [
-                ".gadget/"
-            ]
-        });
-        let gadgetChanges = getChanges(this.ctx, {
-            from: filesVersionHashes,
-            to: gadgetHashes,
-            existing: localHashes
-        });
-        if (localChanges.size === 0 && gadgetChanges.size === 0) {
-            // the local filesystem is missing .gadget/ files
-            gadgetChanges = getChanges(this.ctx, {
-                from: localHashes,
-                to: gadgetHashes
-            });
-            assertAllGadgetFiles({
-                gadgetChanges
+    /**
+   * Pushes any changes made to the local filesystem since the last sync
+   * to Gadget.
+   *
+   * If Gadget has also made changes since the last sync, and --force
+   * was not passed, the user will be prompted to discard them.
+   */ async push(ctx, { hashes, force, printLocalChangesOptions } = {}) {
+        const { localChangesToPush, environmentChanges, environmentFilesVersion, onlyDotGadgetFilesChanged } = hashes ?? await this.hashes(ctx);
+        assert(localChangesToPush.size > 0, "cannot push if there are no changes");
+        // TODO: lift this check up to the push command
+        if (// they didn't pass --force
+        !(force ?? ctx.args["--force"]) && // their environment's files have changed
+        environmentChanges.size > 0 && // some of the changes aren't .gadget/ files
+        !onlyDotGadgetFilesChanged) {
+            await confirm({
+                ensureEmptyLineAbove: true
+            })`
+        Are you sure you want to {underline discard} your environment's changes?
+      `;
+        }
+        try {
+            await this._sendChangesToEnvironment(ctx, {
+                // what changes need to be made to your local files to make
+                // them match the environment's files
+                changes: localChangesToPush,
+                expectedFilesVersion: environmentFilesVersion,
+                printLocalChangesOptions
             });
+        } catch (error) {
+            swallowFilesVersionMismatch(ctx, error);
+            // we were told to push their local changes, but their
+            // environment's files have changed since we last checked, so
+            // throw a nicer error message
+            // TODO: we don't have to do this if only .gadget/ files changed
+            throw new EdgeCaseError(sprint`
+        Your environment's files have changed since we last checked.
+
+        Please re-run "ggt ${ctx.command}" to see the changes and try again.
+      `);
         }
-        assert(localChanges.size > 0 || gadgetChanges.size > 0, "there must be changes if hashes don't match");
+    }
+    async pull(ctx, { hashes, force, printEnvironmentChangesOptions } = {}) {
+        const { localChanges, environmentChangesToPull, environmentFilesVersion } = hashes ?? await this.hashes(ctx);
+        assert(environmentChangesToPull.size > 0, "cannot push if there are no changes");
+        // TODO: lift this check up to the pull command
+        if (localChanges.size > 0 && !(force ?? ctx.args["--force"])) {
+            await confirm`
+        Are you sure you want to {underline discard} your local changes?
+      `;
+        }
+        await this._getChangesFromEnvironment(ctx, {
+            changes: environmentChangesToPull,
+            filesVersion: environmentFilesVersion,
+            printEnvironmentChangesOptions
+        });
+    }
+    async _merge(ctx, { hashes: { localChanges, environmentChanges, environmentFilesVersion }, printLocalChangesOptions, printEnvironmentChangesOptions }) {
         const conflicts = getConflicts({
             localChanges,
-            gadgetChanges
+            environmentChanges
         });
         if (conflicts.size > 0) {
-            this.ctx.log.debug("conflicts detected", {
+            ctx.log.debug("conflicts detected", {
                 conflicts
             });
-            let preference = this.ctx.args["--prefer"];
+            let preference = ctx.args["--prefer"];
             if (!preference) {
-                printConflicts(this.ctx, {
-                    message: sprint`{bold You have conflicting changes with Gadget}`,
+                printConflicts({
                     conflicts
                 });
-                preference = await select(this.ctx, {
-                    message: "How would you like to resolve these conflicts?",
-                    choices: Object.values(ConflictPreference)
-                });
+                preference = await select({
+                    choices: Object.values(MergeConflictPreference)
+                })`
+          {bold How should we resolve these conflicts?}
+        `;
             }
             switch(preference){
-                case ConflictPreference.CANCEL:
+                case MergeConflictPreference.CANCEL:
                     {
                         process.exit(0);
                         break;
                     }
-                case ConflictPreference.LOCAL:
+                case MergeConflictPreference.LOCAL:
                     {
-                        gadgetChanges = withoutConflictingChanges({
+                        environmentChanges = withoutConflictingChanges({
                             conflicts,
-                            changes: gadgetChanges
+                            changes: environmentChanges
                         });
                         break;
                     }
-                case ConflictPreference.GADGET:
+                case MergeConflictPreference.ENVIRONMENT:
                     {
                         localChanges = withoutConflictingChanges({
                             conflicts,
@@ -366,101 +428,66 @@ export class FileSync {
                     }
             }
         }
-        if (gadgetChanges.size > 0) {
-            await this._getChangesFromGadget({
-                changes: gadgetChanges,
-                filesVersion: gadgetFilesVersion
+        if (environmentChanges.size > 0) {
+            await this._getChangesFromEnvironment(ctx, {
+                changes: environmentChanges,
+                filesVersion: environmentFilesVersion,
+                printEnvironmentChangesOptions
             });
         }
         if (localChanges.size > 0) {
-            await this._sendChangesToGadget({
+            await this._sendChangesToEnvironment(ctx, {
                 changes: localChanges,
-                expectedFilesVersion: gadgetFilesVersion
+                expectedFilesVersion: environmentFilesVersion,
+                printLocalChangesOptions
             });
         }
     }
-    async hashes() {
-        const [localHashes, { filesVersionHashes, gadgetHashes, gadgetFilesVersion }] = await Promise.all([
-            // get the hashes of our local files
-            this.directory.hashes(),
-            // get the hashes of our local filesVersion and the latest filesVersion
-            (async ()=>{
-                let gadgetFilesVersion;
-                let gadgetHashes;
-                let filesVersionHashes;
-                if (this.filesVersion === 0n) {
-                    // this is the first time we're syncing, so just get the
-                    // hashes of the latest filesVersion
-                    const { fileSyncHashes } = await this.edit.query({
-                        query: FILE_SYNC_HASHES_QUERY
-                    });
-                    gadgetFilesVersion = BigInt(fileSyncHashes.filesVersion);
-                    gadgetHashes = fileSyncHashes.hashes;
-                    filesVersionHashes = {};
-                } else {
-                    // this isn't the first time we're syncing, so get the hashes
-                    // of the files at our local filesVersion and the latest
-                    // filesVersion
-                    const { fileSyncComparisonHashes } = await this.edit.query({
-                        query: FILE_SYNC_COMPARISON_HASHES_QUERY,
-                        variables: {
-                            filesVersion: String(this.filesVersion)
-                        }
-                    });
-                    gadgetFilesVersion = BigInt(fileSyncComparisonHashes.latestFilesVersionHashes.filesVersion);
-                    gadgetHashes = fileSyncComparisonHashes.latestFilesVersionHashes.hashes;
-                    filesVersionHashes = fileSyncComparisonHashes.filesVersionHashes.hashes;
-                }
-                return {
-                    filesVersionHashes,
-                    gadgetHashes,
-                    gadgetFilesVersion
-                };
-            })()
-        ]);
-        return {
-            filesVersionHashes,
-            localHashes,
-            gadgetHashes,
-            gadgetFilesVersion,
-            inSync: isEqualHashes(this.ctx, localHashes, gadgetHashes)
-        };
-    }
-    async _getChangesFromGadget({ filesVersion, changes }) {
-        this.ctx.log.debug("getting changes from gadget", {
+    async _getChangesFromEnvironment(ctx, { filesVersion, changes, printEnvironmentChangesOptions }) {
+        ctx.log.debug("getting changes from gadget", {
             filesVersion,
             changes
         });
         const created = changes.created();
         const updated = changes.updated();
-        let files = [];
-        if (created.length > 0 || updated.length > 0) {
-            const { fileSyncFiles } = await this.edit.query({
-                query: FILE_SYNC_FILES_QUERY,
-                variables: {
-                    paths: [
-                        ...created,
-                        ...updated
-                    ],
-                    filesVersion: String(filesVersion),
-                    encoding: FileSyncEncoding.Base64
-                }
+        const spinner = spin({
+            ensureEmptyLineAbove: true
+        })(sprintChanges(ctx, {
+            changes,
+            tense: "present",
+            title: sprint`Pulling ${pluralize("file", changes.size)}. ${symbol.arrowLeft}`,
+            ...printEnvironmentChangesOptions
+        }));
+        try {
+            let files = [];
+            if (created.length > 0 || updated.length > 0) {
+                const { fileSyncFiles } = await this.syncJson.edit.query({
+                    query: FILE_SYNC_FILES_QUERY,
+                    variables: {
+                        paths: [
+                            ...created,
+                            ...updated
+                        ],
+                        filesVersion: String(filesVersion),
+                        encoding: FileSyncEncoding.Base64
+                    }
+                });
+                files = fileSyncFiles.files;
+            }
+            await this._writeToLocalFilesystem(ctx, {
+                filesVersion,
+                files,
+                delete: changes.deleted(),
+                spinner,
+                printEnvironmentChangesOptions
             });
-            files = fileSyncFiles.files;
+        } catch (error) {
+            spinner.fail();
+            throw error;
         }
-        await this._writeToLocalFilesystem({
-            filesVersion,
-            files,
-            delete: changes.deleted()
-        });
-        printChanges(this.ctx, {
-            changes,
-            tense: "past",
-            message: sprint`← Received {gray ${dayjs().format("hh:mm:ss A")}}`
-        });
     }
-    async _sendChangesToGadget({ expectedFilesVersion = this.filesVersion, changes, printLimit }) {
-        this.ctx.log.debug("sending changes to gadget", {
+    async _sendChangesToEnvironment(ctx, { changes, expectedFilesVersion = this.syncJson.filesVersion, printLocalChangesOptions }) {
+        ctx.log.debug("sending changes to gadget", {
             expectedFilesVersion,
             changes
         });
@@ -473,13 +500,13 @@ export class FileSync {
                 });
                 return;
             }
-            const absolutePath = this.directory.absolute(normalizedPath);
+            const absolutePath = this.syncJson.directory.absolute(normalizedPath);
             let stats;
             try {
                 stats = await fs.stat(absolutePath);
             } catch (error) {
                 swallowEnoent(error);
-                this.ctx.log.debug("skipping change because file doesn't exist", {
+                ctx.log.debug("skipping change because file doesn't exist", {
                     path: normalizedPath
                 });
                 return;
@@ -501,79 +528,109 @@ export class FileSync {
             });
         });
         if (changed.length === 0 && deleted.length === 0) {
-            this.ctx.log.debug("skipping send because there are no changes");
+            ctx.log.debug("skipping send because there are no changes");
             return;
         }
-        const { publishFileSyncEvents: { remoteFilesVersion, problems } } = await this.edit.mutate({
-            mutation: PUBLISH_FILE_SYNC_EVENTS_MUTATION,
-            variables: {
-                input: {
-                    expectedRemoteFilesVersion: String(expectedFilesVersion),
-                    changed,
-                    deleted
-                }
-            },
-            http: {
-                retry: {
-                    // we can retry this request because
-                    // expectedRemoteFilesVersion makes it idempotent
-                    methods: [
-                        "POST"
-                    ],
-                    calculateDelay: ({ error, computedValue })=>{
-                        if (isFilesVersionMismatchError(error.response?.body)) {
-                            // don't retry if we get a files version mismatch error
-                            return 0;
+        const contentLength = changed.map((change)=>change.content.length).reduce((a, b)=>a + b, 0);
+        if (contentLength > MAX_PUSH_CONTENT_LENGTH) {
+            throw new EdgeCaseError(sprint`
+        {underline Your file changes are too large to push.}
+
+        Run "ggt status" to see your changes and consider
+        ignoring some files or pushing in smaller batches.
+      `);
+        }
+        const spinner = spin({
+            ensureEmptyLineAbove: true
+        })(sprintChanges(ctx, {
+            changes,
+            tense: "present",
+            title: sprintln`Pushing ${pluralize("file", changed.length + deleted.length)}. ${symbol.arrowRight}`,
+            ...printLocalChangesOptions
+        }));
+        try {
+            const { publishFileSyncEvents: { remoteFilesVersion, problems: filesyncProblems } } = await this.syncJson.edit.mutate({
+                mutation: PUBLISH_FILE_SYNC_EVENTS_MUTATION,
+                variables: {
+                    input: {
+                        expectedRemoteFilesVersion: String(expectedFilesVersion),
+                        changed,
+                        deleted
+                    }
+                },
+                http: {
+                    retry: {
+                        // we can retry this request because
+                        // expectedRemoteFilesVersion makes it idempotent
+                        methods: [
+                            "POST"
+                        ],
+                        calculateDelay: ({ error, computedValue })=>{
+                            if (isFilesVersionMismatchError(error.response?.body)) {
+                                // don't retry if we get a files version mismatch error
+                                return 0;
+                            }
+                            return computedValue;
                         }
-                        return computedValue;
                     }
                 }
-            }
-        });
-        printChanges(this.ctx, {
-            changes,
-            tense: "past",
-            message: sprint`→ Sent {gray ${dayjs().format("hh:mm:ss A")}}`,
-            limit: printLimit
-        });
-        if (BigInt(remoteFilesVersion) > expectedFilesVersion + 1n) {
-            // we can't save the remoteFilesVersion because we haven't
-            // received the intermediate filesVersions yet
-            throw new Error("Files version mismatch");
-        }
-        if (problems.length > 0) {
-            const problemGroup = {};
-            problems.forEach((problem)=>{
-                if (!(problem.path in problemGroup)) {
-                    problemGroup[problem.path] = [];
-                }
-                problemGroup[problem.path]?.push(problem.message);
             });
-            this.ctx.log.println2`{red Gadget has detected the following fatal errors with your files:}`;
-            Object.entries(problemGroup).forEach(([path, messages])=>{
-                this.ctx.log.println`{red [${path}]}`;
-                messages.forEach((message)=>{
-                    this.ctx.log.println`{red  - ${message}}`;
-                });
-            });
-            this.ctx.log.println("");
-            this.ctx.log.println2`{red Your app will not be operational until all fatal errors are fixed.}`;
+            if (BigInt(remoteFilesVersion) > expectedFilesVersion + 1n) {
+                // we can't save the remoteFilesVersion because we haven't
+                // received the intermediate filesVersions yet
+                throw new Error("Files version mismatch");
+            }
+            await this.syncJson.save(remoteFilesVersion);
+            spinner.succeed(sprintChanges(ctx, {
+                changes,
+                tense: "past",
+                title: sprintln`Pushed ${pluralize("file", changed.length + deleted.length)}. ${symbol.arrowRight} ${ts()}`,
+                ...printLocalChangesOptions
+            }));
+            if (filesyncProblems.length > 0) {
+                println({
+                    ensureEmptyLineAbove: true
+                })`
+          {red Gadget has detected the following fatal errors with your files:}
+
+          ${sprintProblems({
+                    problems: filesyncProblemsToProblems(filesyncProblems),
+                    showFileTypes: false,
+                    indent: 10
+                })}
+
+          {red Your app will not be operational until all fatal errors are fixed.}
+        `;
+            }
+        } catch (error) {
+            if (isFilesVersionMismatchError(error)) {
+                spinner.clear();
+            } else {
+                spinner.fail();
+            }
+            throw error;
         }
-        await this._save(remoteFilesVersion);
     }
-    async _writeToLocalFilesystem(options) {
+    async _writeToLocalFilesystem(ctx, options) {
         const filesVersion = BigInt(options.filesVersion);
-        assert(filesVersion >= this.filesVersion, "filesVersion must be greater than or equal to current filesVersion");
-        this.ctx.log.debug("writing to local filesystem", {
+        assert(filesVersion >= this.syncJson.filesVersion, "filesVersion must be greater than or equal to current filesVersion");
+        ctx.log.debug("writing to local filesystem", {
             filesVersion,
             files: options.files.map((file)=>file.path),
             delete: options.delete
         });
-        const created = [];
-        const updated = [];
-        await pMap(options.delete, async (filepath)=>{
-            const currentPath = this.directory.absolute(filepath);
-            const backupPath = this.directory.absolute(".gadget/backup", this.directory.relative(filepath));
+        const changes = new Changes();
+        const directoriesWithDeletedFiles = new Set();
+        await pMap(options.delete, async (pathToDelete)=>{
+            // add all the directories that contain this file to
+            // directoriesWithDeletedFiles so we can clean them up later
+            let dir = path.dirname(pathToDelete);
+            while(dir !== "."){
+                directoriesWithDeletedFiles.add(this.syncJson.directory.normalize(dir, true));
+                dir = path.dirname(dir);
+            }
+            const currentPath = this.syncJson.directory.absolute(pathToDelete);
+            const backupPath = this.syncJson.directory.absolute(".gadget/backup", this.syncJson.directory.relative(pathToDelete));
             // rather than `rm -rf`ing files, we move them to
             // `.gadget/backup/` so that users can recover them if something
             // goes wrong. We've seen a lot of EBUSY/EINVAL errors when moving
@@ -584,9 +641,36 @@ export class FileSync {
                     // different type (file vs directory)
                     await fs.remove(backupPath);
                     await fs.move(currentPath, backupPath);
+                    changes.set(pathToDelete, {
+                        type: "delete"
+                    });
                 } catch (error) {
-                    // replicate the behavior of `rm -rf` and ignore ENOENT
-                    swallowEnoent(error);
+                    if (isENOENTError(error)) {
+                        // replicate the behavior of `rm -rf` and ignore ENOENT
+                        return;
+                    }
+                    if (isENOTDIRError(error) || isEEXISTError(error)) {
+                        // the backup path already exists and ends in a file
+                        // rather than a directory, so we have to remove the file
+                        // before we can move the current path to the backup path
+                        let dir = path.dirname(backupPath);
+                        while(dir !== this.syncJson.directory.absolute(".gadget/backup")){
+                            const stats = await fs.stat(dir);
+                            // eslint-disable-next-line max-depth
+                            if (!stats.isDirectory()) {
+                                // this file is in the way, so remove it
+                                ctx.log.debug("removing file in the way of backup path", {
+                                    currentPath,
+                                    backupPath,
+                                    file: dir
+                                });
+                                await fs.remove(dir);
+                            }
+                            dir = path.dirname(dir);
+                        }
+                    // still throw the error so we retry
+                    }
+                    throw error;
                 }
             }, {
                 // windows tends to run into these issues way more often than
@@ -594,7 +678,7 @@ export class FileSync {
                 retries: config.windows ? 4 : 2,
                 minTimeout: ms("100ms"),
                 onFailedAttempt: (error)=>{
-                    this.ctx.log.warn("failed to move file to backup", {
+                    ctx.log.warn("failed to move file to backup", {
                         error,
                         currentPath,
                         backupPath
@@ -602,12 +686,38 @@ export class FileSync {
                 }
             });
         });
+        for (const directoryWithDeletedFile of Array.from(directoriesWithDeletedFiles.values()).sort().reverse()){
+            if (options.files.some((file)=>file.path === directoryWithDeletedFile)) {
+                continue;
+            }
+            try {
+                // delete any empty directories that contained a deleted file.
+                // if the empty directory should continue to exist, we would
+                // have received an event to create it above
+                await fs.rmdir(this.syncJson.directory.absolute(directoryWithDeletedFile));
+                changes.set(directoryWithDeletedFile, {
+                    type: "delete"
+                });
+            } catch (error) {
+                if (isENOENTError(error) || isENOTEMPTYError(error)) {
+                    continue;
+                }
+                throw error;
+            }
+        }
         await pMap(options.files, async (file)=>{
-            const absolutePath = this.directory.absolute(file.path);
+            const absolutePath = this.syncJson.directory.absolute(file.path);
             if (await fs.pathExists(absolutePath)) {
-                updated.push(file.path);
+                if (!file.path.endsWith("/")) {
+                    // only track file updates, not directory updates
+                    changes.set(file.path, {
+                        type: "update"
+                    });
+                }
             } else {
-                created.push(file.path);
+                changes.set(file.path, {
+                    type: "create"
+                });
             }
             if (file.path.endsWith("/")) {
                 await fs.ensureDir(absolutePath);
@@ -620,167 +730,57 @@ export class FileSync {
                 // ensure the file has the correct mode
                 await fs.chmod(absolutePath, file.mode & 0o777);
             }
-            if (absolutePath === this.directory.absolute(".ignore")) {
-                await this.directory.loadIgnoreFile();
+            if (absolutePath === this.syncJson.directory.absolute(".ignore")) {
+                await this.syncJson.directory.loadIgnoreFile();
             }
         });
-        await this._save(String(filesVersion));
-        const changes = new Changes([
-            ...created.map((path)=>[
-                    path,
-                    {
-                        type: "create"
-                    }
-                ]),
-            ...updated.map((path)=>[
-                    path,
-                    {
-                        type: "update"
-                    }
-                ]),
-            ...options.delete.map((path)=>[
-                    path,
-                    {
-                        type: "delete"
-                    }
-                ])
-        ]);
+        await this.syncJson.save(String(filesVersion));
+        options.spinner?.clear();
+        printChanges(ctx, {
+            changes,
+            tense: "past",
+            title: sprint`{green ${symbol.tick}} Pulled ${pluralize("file", changes.size)}. ${symbol.arrowLeft} ${ts()}`,
+            ...options.printEnvironmentChangesOptions
+        });
         if (changes.has("yarn.lock")) {
-            this.ctx.log.info("running yarn install --check-files");
-            await execa("yarn", [
-                "install",
-                "--check-files"
-            ], {
-                cwd: this.directory.path
-            }).then(()=>this.ctx.log.info("yarn install complete")).catch((error)=>this.ctx.log.error("yarn install failed", {
+            const spinner = spin({
+                ensureEmptyLineAbove: true
+            })('Running "yarn install --check-files"');
+            try {
+                await execa("yarn", [
+                    "install",
+                    "--check-files"
+                ], {
+                    cwd: this.syncJson.directory.path
+                });
+                spinner.succeed`Ran "yarn install --check-files" ${ts()}`;
+            } catch (error) {
+                spinner.fail();
+                ctx.log.error("yarn install failed", {
                     error
-                }));
+                });
+                const message = serializeError(error).message;
+                if (message) {
+                    println({
+                        ensureEmptyLineAbove: true,
+                        indent: 2
+                    })(message);
+                }
+            }
         }
         return changes;
     }
-    /**
-   * Updates {@linkcode _syncJson} and saves it to `.gadget/sync.json`.
-   */ async _save(filesVersion) {
-        this._syncJson = {
-            ...this._syncJson,
-            mtime: Date.now() + 1,
-            filesVersion: String(filesVersion)
-        };
-        this.ctx.log.debug("saving .gadget/sync.json");
-        await fs.outputJSON(this.directory.absolute(".gadget/sync.json"), this._syncJson, {
-            spaces: 2
-        });
-    }
-    constructor(/**
-     * The {@linkcode Context} that was used to initialize this
-     * {@linkcode FileSync} instance.
-     */ ctx, /**
-     * The directory that is being synced to.
-     */ directory, /**
-     * The Gadget application that is being synced to.
-     */ app, /**
-     * The state of the filesystem.
-     *
-     * This is persisted to `.gadget/sync.json` within the {@linkcode directory}.
-     */ _syncJson){
-        _define_property(this, "ctx", void 0);
-        _define_property(this, "directory", void 0);
-        _define_property(this, "app", void 0);
-        _define_property(this, "_syncJson", void 0);
-        _define_property(this, "edit", void 0);
+    constructor(syncJson){
+        _define_property(this, "syncJson", void 0);
         /**
    * A FIFO async callback queue that ensures we process filesync events
    * in the order we receive them.
    */ _define_property(this, "_syncOperations", void 0);
-        this.ctx = ctx;
-        this.directory = directory;
-        this.app = app;
-        this._syncJson = _syncJson;
+        this.syncJson = syncJson;
         this._syncOperations = new PQueue({
             concurrency: 1
         });
-        this.ctx = ctx.child({
-            fields: ()=>({
-                    filesync: {
-                        directory: this.directory.path,
-                        filesVersion: this.filesVersion
-                    }
-                })
-        });
-        this.edit = new Edit(this.ctx);
     }
 }
-/**
- * Checks if a directory is empty or non-existent.
- *
- * @param dir - The directory path to check.
- * @returns A Promise that resolves to a boolean indicating whether the directory is empty or non-existent.
- */ export const isEmptyOrNonExistentDir = async (dir)=>{
-    try {
-        for await (const _ of (await fs.opendir(dir, {
-            bufferSize: 1
-        }))){
-            return false;
-        }
-        return true;
-    } catch (error) {
-        swallowEnoent(error);
-        return true;
-    }
-};
-export const assertAllGadgetFiles = ({ gadgetChanges })=>{
-    assert(gadgetChanges.created().length > 0 || gadgetChanges.deleted().length > 0 || gadgetChanges.updated().length > 0, "expected gadgetChanges to have changes");
-    const allGadgetFiles = Array.from(gadgetChanges.keys()).every((path)=>path.startsWith(".gadget/"));
-    assert(allGadgetFiles, "expected all gadgetChanges to be .gadget/ files");
-};
-export const ConflictPreference = Object.freeze({
-    CANCEL: "Cancel (Ctrl+C)",
-    LOCAL: "Keep my conflicting changes",
-    GADGET: "Keep Gadget's conflicting changes"
-});
-export const ConflictPreferenceArg = (value, name)=>{
-    if ([
-        "local",
-        "gadget"
-    ].includes(value)) {
-        return ConflictPreference[value.toUpperCase()];
-    }
-    throw new ArgError(sprint`
-      ${name} must be {bold local} or {bold gadget}
-
-      {bold EXAMPLES:}
-        ${name} local
-        ${name} gadget
-    `);
-};
-export const FileSyncArgs = {
-    "--app": {
-        type: AppArg,
-        alias: "-a"
-    },
-    "--prefer": ConflictPreferenceArg,
-    "--force": Boolean
-};
-export const isFilesVersionMismatchError = (error)=>{
-    if (error instanceof EditError) {
-        error = error.cause;
-    }
-    if (isGraphQLResult(error)) {
-        error = error.errors;
-    }
-    if (isGraphQLErrors(error)) {
-        error = error[0];
-    }
-    return isObject(error) && "message" in error && isString(error.message) && error.message.includes("Files version mismatch");
-};
-const swallowFilesVersionMismatch = (ctx, error)=>{
-    if (isFilesVersionMismatchError(error)) {
-        ctx.log.debug("swallowing files version mismatch", {
-            error
-        });
-        return;
-    }
-    throw error;
-};
 
 //# sourceMappingURL=filesync.js.map