framer-code-link 0.1.3 → 0.2.0

package/src/controller.ts

@@ -26,8 +26,23 @@ import {
   autoResolveConflicts,
 } from "./helpers/files.js"
 import { Installer } from "./helpers/installer.js"
-import { createHashTracker } from "./utils/hashing.js"
-import { info, warn, error, success, debug } from "./utils/logging.js"
+import { createHashTracker } from "./utils/hash-tracker.js"
+import {
+  info,
+  warn,
+  error,
+  success,
+  debug,
+  status,
+  fileDown,
+  fileUp,
+  fileDelete,
+  scheduleDisconnectMessage,
+  cancelDisconnectMessage,
+  didShowDisconnect,
+  wasRecentlyDisconnected,
+  resetDisconnectState,
+} from "./utils/logging.js"
 import { hashFileContent } from "./utils/state-persistence.js"
 import {
   FileMetadataCache,
@@ -36,6 +51,7 @@ import {
 import { UserActionCoordinator } from "./helpers/user-actions.js"
 import { validateIncomingChange } from "./helpers/sync-validator.js"
 import { findOrCreateProjectDir } from "./utils/project.js"
+import { pluralize, shortProjectHash } from "@code-link/shared"
 
 /**
  * Explicit sync lifecycle modes
@@ -145,7 +161,12 @@ type Effect =
   | { type: "SEND_MESSAGE"; payload: OutgoingMessage }
   | { type: "LIST_LOCAL_FILES" }
   | { type: "DETECT_CONFLICTS"; remoteFiles: FileInfo[] }
-  | { type: "WRITE_FILES"; files: FileInfo[] }
+  | {
+      type: "WRITE_FILES"
+      files: FileInfo[]
+      silent?: boolean
+      skipEcho?: boolean // when true, skip writes that match hashTracker (inbound echo)
+    }
   | { type: "DELETE_LOCAL_FILES"; names: string[] }
   | { type: "REQUEST_CONFLICT_DECISIONS"; conflicts: Conflict[] }
   | { type: "REQUEST_CONFLICT_VERSIONS"; conflicts: Conflict[] }
@@ -170,6 +191,12 @@ type Effect =
       requireConfirmation: boolean
     }
   | { type: "PERSIST_STATE" }
+  | {
+      type: "SYNC_COMPLETE"
+      totalCount: number
+      updatedCount: number
+      unchangedCount: number
+    }
   | { type: "LOG"; level: "info" | "debug" | "warn"; message: string }
 
 /** Log helper */
@@ -177,6 +204,20 @@ function log(level: "info" | "debug" | "warn", message: string): Effect {
   return { type: "LOG", level, message }
 }
 
+/**
+ * Filter out files whose content matches the last remembered hash.
+ * Used to skip inbound echoes of our own local sends.
+ */
+export function filterEchoedFiles(
+  files: FileInfo[],
+  hashTracker: ReturnType<typeof createHashTracker>
+): FileInfo[] {
+  return files.filter((file) => {
+    if (file.content === undefined) return true
+    return !hashTracker.shouldSkip(file.name, file.content)
+  })
+}
+
 /**
  * Pure state transition function
  * Takes current state + event, returns new state + effects to execute
@@ -214,7 +255,7 @@ function transition(
 
     case "FILE_SYNCED": {
       // Remote confirms they received our local change
-      effects.push(log("info", `Remote confirmed sync: ${event.fileName}`), {
+      effects.push(log("debug", `Remote confirmed sync: ${event.fileName}`), {
         type: "UPDATE_FILE_METADATA",
         fileName: event.fileName,
         remoteModifiedAt: event.remoteModifiedAt,
@@ -226,7 +267,7 @@ function transition(
     case "DISCONNECT": {
       effects.push(
         { type: "PERSIST_STATE" },
-        log("info", "Disconnected, persisting state")
+        log("debug", "Disconnected, persisting state")
       )
 
       if (state.mode === "conflict_resolution") {
@@ -261,7 +302,7 @@ function transition(
         return { state, effects }
       }
 
-      effects.push(log("info", "Plugin requested file list"), {
+      effects.push(log("debug", "Plugin requested file list"), {
         type: "LIST_LOCAL_FILES",
       })
 
@@ -277,7 +318,7 @@ function transition(
       }
 
       effects.push(
-        log("info", `Received file list: ${event.files.length} files`)
+        log("debug", `Received file list: ${event.files.length} files`)
       )
 
       // Detect conflicts between remote snapshot and local files
@@ -310,23 +351,24 @@ function transition(
 
       const { conflicts, safeWrites, localOnly } = event
 
-      // detectConflicts already did auto-resolution:
+      // detectConflicts returns:
       // - safeWrites = files we can apply (remote-only or local unchanged)
-      // - conflicts = files that need manual resolution (both sides changed)
+      // - conflicts = files that need manual resolution (content or deletion conflicts)
       // - localOnly = files to upload
+      // (unchanged files have metadata recorded in DETECT_CONFLICTS executor)
 
       // Apply safe writes
       if (safeWrites.length > 0) {
-        effects.push(log("info", `Applying ${safeWrites.length} safe writes`), {
-          type: "WRITE_FILES",
-          files: safeWrites,
-        })
+        effects.push(
+          log("debug", `Applying ${safeWrites.length} safe writes`),
+          { type: "WRITE_FILES", files: safeWrites, silent: true }
+        )
       }
 
       // Upload local-only files
       if (localOnly.length > 0) {
         effects.push(
-          log("info", `Uploading ${localOnly.length} local-only files`)
+          log("debug", `Uploading ${localOnly.length} local-only files`)
         )
         for (const file of localOnly) {
           effects.push({
@@ -340,16 +382,12 @@ function transition(
         }
       }
 
-      // If potential conflicts remain, request remote version data before surfacing to user
+      // If conflicts remain, request remote version data before surfacing to user
       if (conflicts.length > 0) {
         effects.push(
           log(
-            "warn",
-            `${conflicts.length} conflicts require version verification`
-          ),
-          log(
-            "info",
-            "[CONFLICTS] Requesting remote version data from plugin..."
+            "debug",
+            `${pluralize(conflicts.length, "conflict")} require version check`
           ),
           { type: "REQUEST_CONFLICT_VERSIONS", conflicts }
         )
@@ -365,9 +403,19 @@ function transition(
       }
 
       // No conflicts - transition to watching
-      effects.push(log("info", "Initial sync complete, entering watch mode"), {
-        type: "PERSIST_STATE",
-      })
+      const remoteTotal = state.queuedDiffs.length
+      const totalCount = remoteTotal + localOnly.length
+      const updatedCount = safeWrites.length + localOnly.length
+      const unchangedCount = Math.max(0, remoteTotal - safeWrites.length)
+      effects.push(
+        { type: "PERSIST_STATE" },
+        {
+          type: "SYNC_COMPLETE",
+          totalCount,
+          updatedCount,
+          unchangedCount,
+        }
+      )
 
       return {
         state: {
@@ -415,9 +463,10 @@ function transition(
       }
 
       // Apply the change
-      effects.push(log("info", `Applying remote change: ${event.file.name}`), {
+      effects.push(log("debug", `Applying remote change: ${event.file.name}`), {
         type: "WRITE_FILES",
         files: [event.file],
+        skipEcho: true,
       })
 
       return { state, effects }
@@ -435,7 +484,7 @@ function transition(
       // Remote deletes should always be applied immediately
       // (the file is already gone from Framer)
       effects.push(
-        log("info", `Remote delete applied: ${event.fileName}`),
+        log("debug", `Remote delete applied: ${event.fileName}`),
         { type: "DELETE_LOCAL_FILES", names: [event.fileName] },
         { type: "PERSIST_STATE" }
       )
@@ -446,7 +495,7 @@ function transition(
     case "REMOTE_DELETE_CONFIRMED": {
       // User confirmed the delete - apply it
       effects.push(
-        log("info", `Delete confirmed: ${event.fileName}`),
+        log("debug", `Delete confirmed: ${event.fileName}`),
         { type: "DELETE_LOCAL_FILES", names: [event.fileName] },
         { type: "PERSIST_STATE" }
       )
@@ -456,7 +505,7 @@ function transition(
 
     case "REMOTE_DELETE_CANCELLED": {
       // User cancelled - restore the file
-      effects.push(log("info", `Delete cancelled: ${event.fileName}`))
+      effects.push(log("debug", `Delete cancelled: ${event.fileName}`))
       effects.push({
         type: "WRITE_FILES",
         files: [
@@ -485,41 +534,74 @@ function transition(
 
       // User picked one resolution for ALL conflicts
       if (event.resolution === "remote") {
-        // Apply all remote versions
-        const remoteFiles = state.pendingConflicts.map((c) => ({
-          name: c.fileName,
-          content: c.remoteContent,
-          modifiedAt: c.remoteModifiedAt,
-        }))
-
+        // Apply all remote versions (or delete locally if remote is null)
+        for (const conflict of state.pendingConflicts) {
+          if (conflict.remoteContent === null) {
+            // Remote deleted this file - delete locally
+            effects.push({
+              type: "DELETE_LOCAL_FILES",
+              names: [conflict.fileName],
+            })
+          } else {
+            effects.push({
+              type: "WRITE_FILES",
+              files: [
+                {
+                  name: conflict.fileName,
+                  content: conflict.remoteContent,
+                  modifiedAt: conflict.remoteModifiedAt,
+                },
+              ],
+            })
+          }
+        }
         effects.push(
-          log("info", `Applying ${remoteFiles.length} remote versions`),
-          { type: "WRITE_FILES", files: remoteFiles }
+          log(
+            "debug",
+            `Applied ${state.pendingConflicts.length} remote versions`
+          )
         )
       } else {
-        // Send all local versions
+        // Send all local versions (or delete from Framer if local is null)
+        for (const conflict of state.pendingConflicts) {
+          if (conflict.localContent === null) {
+            // Local deleted this file - delete from Framer
+            effects.push({
+              type: "SEND_MESSAGE",
+              payload: {
+                type: "file-delete",
+                fileNames: [conflict.fileName],
+              },
+            })
+          } else {
+            effects.push({
+              type: "SEND_MESSAGE",
+              payload: {
+                type: "file-change",
+                fileName: conflict.fileName,
+                content: conflict.localContent,
+              },
+            })
+          }
+        }
         effects.push(
           log(
-            "info",
-            `Applying ${state.pendingConflicts.length} local versions`
+            "debug",
+            `Applied ${state.pendingConflicts.length} local versions`
           )
         )
-        for (const conflict of state.pendingConflicts) {
-          effects.push({
-            type: "SEND_MESSAGE",
-            payload: {
-              type: "file-change",
-              fileName: conflict.fileName,
-              content: conflict.localContent,
-            },
-          })
-        }
       }
 
       // All conflicts resolved - transition to watching
-      effects.push(log("info", "All conflicts resolved, entering watch mode"), {
-        type: "PERSIST_STATE",
-      })
+      effects.push(
+        { type: "PERSIST_STATE" },
+        {
+          type: "SYNC_COMPLETE",
+          totalCount: state.pendingConflicts.length,
+          updatedCount: state.pendingConflicts.length,
+          unchangedCount: 0,
+        }
+      )
 
       const { pendingConflicts: _discarded, ...rest } = state
       return {
@@ -556,7 +638,6 @@ function transition(
             return { state, effects }
           }
 
-          effects.push(log("info", `Local change detected: ${relativePath}`))
           effects.push({
             type: "SEND_LOCAL_CHANGE",
             fileName: relativePath,
@@ -566,7 +647,7 @@ function transition(
         }
 
         case "delete": {
-          effects.push(log("info", `Local delete detected: ${relativePath}`), {
+          effects.push(log("debug", `Local delete detected: ${relativePath}`), {
             type: "REQUEST_LOCAL_DELETE_DECISION",
             fileName: relativePath,
             requireConfirmation: true, // Will be overridden by config in effect
@@ -595,41 +676,64 @@ function transition(
       if (autoResolvedLocal.length > 0) {
         effects.push(
           log(
-            "info",
-            `[AUTO-RESOLVE] Applying ${autoResolvedLocal.length} local changes`
+            "debug",
+            `Auto-resolved ${autoResolvedLocal.length} local changes`
           )
         )
         for (const conflict of autoResolvedLocal) {
-          effects.push({
-            type: "SEND_LOCAL_CHANGE",
-            fileName: conflict.fileName,
-            content: conflict.localContent,
-          })
+          if (conflict.localContent === null) {
+            // Local deleted - delete from Framer
+            effects.push({
+              type: "SEND_MESSAGE",
+              payload: {
+                type: "file-delete",
+                fileNames: [conflict.fileName],
+              },
+            })
+          } else {
+            effects.push({
+              type: "SEND_LOCAL_CHANGE",
+              fileName: conflict.fileName,
+              content: conflict.localContent,
+            })
+          }
         }
       }
 
       if (autoResolvedRemote.length > 0) {
         effects.push(
           log(
-            "info",
-            `[AUTO-RESOLVE] Applying ${autoResolvedRemote.length} remote changes`
-          ),
-          {
-            type: "WRITE_FILES",
-            files: autoResolvedRemote.map((conflict) => ({
-              name: conflict.fileName,
-              content: conflict.remoteContent,
-              modifiedAt: conflict.remoteModifiedAt ?? Date.now(),
-            })),
-          }
+            "debug",
+            `Auto-resolved ${autoResolvedRemote.length} remote changes`
+          )
         )
+        for (const conflict of autoResolvedRemote) {
+          if (conflict.remoteContent === null) {
+            // Remote deleted - delete locally
+            effects.push({
+              type: "DELETE_LOCAL_FILES",
+              names: [conflict.fileName],
+            })
+          } else {
+            effects.push({
+              type: "WRITE_FILES",
+              files: [
+                {
+                  name: conflict.fileName,
+                  content: conflict.remoteContent,
+                  modifiedAt: conflict.remoteModifiedAt ?? Date.now(),
+                },
+              ],
+            })
+          }
+        }
       }
 
       if (remainingConflicts.length > 0) {
         effects.push(
           log(
             "warn",
-            `[AUTO-RESOLVE] ${remainingConflicts.length} conflicts require user resolution`
+            `${pluralize(remainingConflicts.length, "conflict")} require resolution`
           ),
           { type: "REQUEST_CONFLICT_DECISIONS", conflicts: remainingConflicts }
         )
@@ -643,9 +747,16 @@ function transition(
         }
       }
 
-      effects.push(log("info", "[AUTO-RESOLVE] All conflicts auto-resolved!"), {
-        type: "PERSIST_STATE",
-      })
+      const resolvedCount = autoResolvedLocal.length + autoResolvedRemote.length
+      effects.push(
+        { type: "PERSIST_STATE" },
+        {
+          type: "SYNC_COMPLETE",
+          totalCount: resolvedCount,
+          updatedCount: resolvedCount,
+          unchangedCount: 0,
+        }
+      )
 
       const { pendingConflicts: _discarded, ...rest } = state
       return {
@@ -701,7 +812,7 @@ async function executeEffect(
           config.explicitDir
         )
         config.filesDir = `${config.projectDir}/files`
-        info(`Files directory: ${config.filesDir}`)
+        debug(`Files directory: ${config.filesDir}`)
 
         // Create files directory
         await fs.mkdir(config.filesDir, { recursive: true })
@@ -712,7 +823,7 @@ async function executeEffect(
     case "LOAD_PERSISTED_STATE": {
       if (config.projectDir) {
         await fileMetadataCache.initialize(config.projectDir)
-        info(`Loaded persisted metadata for ${fileMetadataCache.size()} files`)
+        debug(`Loaded persisted metadata for ${fileMetadataCache.size()} files`)
       }
       return []
     }
@@ -741,12 +852,22 @@ async function executeEffect(
       }
 
       // Use existing helper to detect conflicts
-      const { conflicts, writes, localOnly } = await detectConflicts(
+      const { conflicts, writes, localOnly, unchanged } = await detectConflicts(
         effect.remoteFiles,
         config.filesDir,
         { persistedState: fileMetadataCache.getPersistedState() }
       )
 
+      // Record metadata for unchanged files so watcher add events get skipped
+      // (chokidar ignoreInitial=false fires late adds that would otherwise re-upload)
+      for (const file of unchanged) {
+        fileMetadataCache.recordRemoteWrite(
+          file.name,
+          file.content,
+          file.modifiedAt ?? Date.now()
+        )
+      }
+
       // Return CONFLICTS_DETECTED event to continue the flow
       return [
         {
@@ -772,13 +893,32 @@ async function executeEffect(
 
     case "WRITE_FILES": {
       if (config.filesDir) {
+        // skipEcho is opt-in: some callers still need side-effects (metadata/logs)
+        // even when content matches the last hash tracked in-memory.
+        const filesToWrite =
+          effect.skipEcho === true
+            ? filterEchoedFiles(effect.files, hashTracker)
+            : effect.files
+
+        if (effect.skipEcho && filesToWrite.length !== effect.files.length) {
+          const skipped = effect.files.length - filesToWrite.length
+          debug(`Skipped ${pluralize(skipped, "echoed change")}`)
+        }
+
+        if (filesToWrite.length === 0) {
+          return []
+        }
+
         await writeRemoteFiles(
-          effect.files,
+          filesToWrite,
           config.filesDir,
           hashTracker,
           installer ?? undefined
         )
-        for (const file of effect.files) {
+        for (const file of filesToWrite) {
+          if (!effect.silent) {
+            fileDown(file.name)
+          }
           const remoteTimestamp = file.modifiedAt ?? Date.now()
           fileMetadataCache.recordRemoteWrite(
             file.name,
@@ -794,6 +934,7 @@ async function executeEffect(
       if (config.filesDir) {
         for (const fileName of effect.names) {
           await deleteLocalFile(fileName, config.filesDir, hashTracker)
+          fileDelete(fileName)
           fileMetadataCache.recordDelete(fileName)
         }
       }
@@ -824,8 +965,8 @@ async function executeEffect(
         }
       })
 
-      info(
-        `[CONFLICTS] Requesting remote version data for ${versionRequests.length} file(s)`
+      debug(
+        `Requesting remote version data for ${pluralize(versionRequests.length, "file")}`
       )
 
       await sendMessage(syncState.socket, {
@@ -873,10 +1014,24 @@ async function executeEffect(
     }
 
     case "SEND_LOCAL_CHANGE": {
+      const contentHash = hashFileContent(effect.content)
+      const metadata = fileMetadataCache.get(effect.fileName)
+
+      // Skip if file matches last confirmed remote content
+      if (metadata?.lastSyncedHash === contentHash) {
+        debug(
+          `Skipping local change for ${effect.fileName}: matches last synced content`
+        )
+        return []
+      }
+
       // Echo prevention: skip if we just wrote this exact content
       if (hashTracker.shouldSkip(effect.fileName, effect.content)) {
         return []
       }
+
+      debug(`Local change detected: ${effect.fileName}`)
+
       try {
         // Send change to plugin
         if (syncState.socket) {
@@ -885,6 +1040,7 @@ async function executeEffect(
             fileName: effect.fileName,
             content: effect.content,
           })
+          fileUp(effect.fileName)
         }
 
         // Only remember hash after successful send (prevents re-sending on failure)
@@ -895,10 +1051,7 @@ async function executeEffect(
           installer.process(effect.fileName, effect.content)
         }
       } catch (err) {
-        console.warn(
-          `Failed to push change for ${effect.fileName}, will re-sync on next diff:`,
-          err
-        )
+        warn(`Failed to push ${effect.fileName}`)
       }
 
       return []
@@ -946,6 +1099,33 @@ async function executeEffect(
       return []
     }
 
+    case "SYNC_COMPLETE": {
+      const wasDisconnected = wasRecentlyDisconnected()
+
+      // Notify plugin that sync is complete
+      if (syncState.socket) {
+        await sendMessage(syncState.socket, { type: "sync-complete" })
+      }
+
+      if (wasDisconnected) {
+        // Only show reconnect message if we actually showed the disconnect notice
+        if (didShowDisconnect()) {
+          success(
+            `Reconnected, synced ${effect.totalCount} files (${effect.updatedCount} updated, ${effect.unchangedCount} unchanged)`
+          )
+          status("Watching for changes...")
+        }
+        resetDisconnectState()
+        return []
+      }
+
+      success(
+        `Synced ${effect.totalCount} files (${effect.updatedCount} updated, ${effect.unchangedCount} unchanged)`
+      )
+      status("Watching for changes...")
+      return []
+    }
+
     case "LOG": {
       const logFn =
         effect.level === "info" ? info : effect.level === "warn" ? warn : debug
@@ -959,9 +1139,7 @@ async function executeEffect(
  * Starts the sync controller with the given configuration
  */
 export async function start(config: Config): Promise<void> {
-  info("🚀 Starting Code Link")
-  info(`Project: ${config.projectHash}`)
-  info(`Port: ${config.port} (auto-selected from project hash)`)
+  status("Waiting for Plugin connection...")
 
   const hashTracker = createHashTracker()
   const fileMetadataCache = new FileMetadataCache()
@@ -982,7 +1160,7 @@ export async function start(config: Config): Promise<void> {
   // Process events through state machine and execute effects recursively
   async function processEvent(event: SyncEvent) {
     const socketState = syncState.socket?.readyState
-    info(
+    debug(
       `[STATE] Processing event: ${event.type} (mode: ${syncState.mode}, socket: ${socketState ?? "none"})`
     )
 
@@ -990,7 +1168,7 @@ export async function start(config: Config): Promise<void> {
     syncState = result.state
 
     if (result.effects.length > 0) {
-      info(
+      debug(
         `[STATE] Event produced ${result.effects.length} effects: ${result.effects.map((e) => e.type).join(", ")}`
       )
     }
@@ -1000,7 +1178,7 @@ export async function start(config: Config): Promise<void> {
       // Check socket state before each effect
       const currentSocketState = syncState.socket?.readyState
       if (currentSocketState !== undefined && currentSocketState !== 1) {
-        warn(
+        debug(
           `[STATE] Socket not open (state: ${currentSocketState}) before executing ${effect.type}`
         )
       }
@@ -1026,13 +1204,14 @@ export async function start(config: Config): Promise<void> {
 
   // Handle initial handshake
   connection.on("handshake", async (client: WebSocket, message) => {
-    info("Received handshake from plugin")
-    info(`Project: ${message.projectName} (${message.projectId})`)
+    debug(`Received handshake: ${message.projectName} (${message.projectId})`)
 
-    // Validate project hash
-    if (message.projectId !== config.projectHash) {
+    // Validate project hash (normalize both to short hash for comparison)
+    const expectedShort = shortProjectHash(config.projectHash)
+    const receivedShort = shortProjectHash(message.projectId)
+    if (receivedShort !== expectedShort) {
       warn(
-        `Project ID mismatch: expected ${config.projectHash}, got ${message.projectId}`
+        `Project ID mismatch: expected ${expectedShort}, got ${receivedShort}`
       )
       client.close()
       return
@@ -1056,7 +1235,15 @@ export async function start(config: Config): Promise<void> {
       startWatcher()
     }
 
-    success("Handshake successful - connection established")
+    // Cancel any pending disconnect message (fast reconnect)
+    cancelDisconnectMessage()
+
+    // Only show "Connected" on initial connection, not reconnects
+    // Reconnect confirmation happens in SYNC_COMPLETE
+    const wasDisconnected = wasRecentlyDisconnected()
+    if (!wasDisconnected && !didShowDisconnect()) {
+      success(`Connected to ${message.projectName}`)
+    }
   })
 
   // Message Handler
@@ -1080,8 +1267,8 @@ export async function start(config: Config): Promise<void> {
           (sum, f) => sum + (f.content?.length ?? 0),
           0
         )
-        info(
-          `[FILE_LIST] Received ${message.files.length} files (${(totalSize / 1024).toFixed(1)}KB total)`
+        debug(
+          `Received file list: ${message.files.length} files (${(totalSize / 1024).toFixed(1)}KB)`
         )
         event = { type: "FILE_LIST", files: message.files }
         break
@@ -1188,10 +1375,12 @@ export async function start(config: Config): Promise<void> {
   })
 
   connection.on("disconnect", async () => {
-    warn("Plugin disconnected")
+    // Schedule disconnect message with delay - if reconnect happens quickly, we skip it
+    scheduleDisconnectMessage(() => {
+      status("Disconnected, waiting to reconnect...")
+    })
     await processEvent({ type: "DISCONNECT" })
     userActions.cleanup()
-    info("Will perform full diff on reconnect")
   })
 
   connection.on("error", (err) => {
@@ -1212,14 +1401,12 @@ export async function start(config: Config): Promise<void> {
     })
   }
 
-  // Lifecycle
-
-  info("✓ Controller initialized and ready")
-  info(`Waiting for plugin connection on port ${config.port}...`)
+  // Lifecycle - no additional startup messages needed (banner shown in index.ts)
 
   // Graceful shutdown
   process.on("SIGINT", async () => {
-    info("\nShutting down gracefully...")
+    console.log() // newline after ^C
+    status("Shutting down...")
     if (watcher) {
       await watcher.close()
     }