         (println "Figwheel: Watching build -" (:id build-config))
         (flush)
         ;; setup
-        (fig-inject/delete-connect-scripts! [build-config])
+        (figwheel-sidecar.injection/delete-connect-scripts! [build-config])
         ;; TODO this should be conditional based on a flag
         #_(clean-cljs-build* (:build-options build-config))
-        ;; initial build only needs the injection
-        ((figwheel-sidecar.injection/build-hook cljs-build) this)
+        ;; initial build only needs the injection and the
+        ;; start and end messages
+        ((-> cljs-build
+             figwheel-sidecar.injection/build-hook
+             figwheel-start-and-end-messages) this)
         (let [log-writer (or log-writer (io/writer "figwheel_server.log" :append true))]
           (assoc this
                  :file-watcher

   :all-builds (get-project-builds)})

;; TODO just for dev
(defonce system
  (atom
   (create-figwheel-system* temp-config)))

;; TODO just for dev
(count (:builds @system))
(keys @system)

;; TODO just for dev
(defn start []
  (swap! system component/start))
;; TODO just for dev
(defn stop []
  (swap! system component/stop))
;; TODO just for dev
(defn reload []
  (swap! system component/stop)
  (require 'figwheel-sidecar.system :reload)
  (swap! system component/start))


(defn stop-autobuild [system ids]
  (repl-println "Figwheel: Stoping autobuild")
  (swap! system component/stop-system (ids-or-all-build-keys system ids))
  nil)

(defn start-autobuild [system ids]
  (repl-println "Figwheel: Starting autobuild")
  (when (not-empty ids)
    (patch-system-builds system ids))
  (swap! system component/start-system (ids-or-all-build-keys system ids))
  nil)

(defn switch-to-build [system ids]
  (when (not-empty ids)
    (start-autobuild system ids))
  nil)

(defn clean-build [system id]
  (let [{:keys [builds]} @system]
    (when-let [{:keys [build-options]} (get builds (name id))]
      (repl-println "Figwheel: Cleaning build -" id)
      (clean-cljs-build* build-options)))
  nil)

(defn clean-builds [system ids]
  (let [ids (map key->id (ids-or-all-build-keys system ids))]
    (doseq [id ids]
      (clean-build system id)))
  nil)

(defn build-once* [system id]
  (when-let [build-config (get (:builds @system) (name id))]
