@newsails/veil-studio 1.0.0 → 2.0.0

package/server/utils/board-state.js

@@ -2,6 +2,8 @@
 
 const { randomUUID } = require('crypto')
 const { getIO } = require('./socket-io.js')
+const hooks = require('./board-hooks.js')
+const { getElementType } = require('./element-registry.js')
 const {
   dbGetElements, dbGetElement, dbInsertElement, dbUpdateElement, dbDeleteElement,
   dbGetLinks, dbInsertLink, dbDeleteLink,
@@ -61,14 +63,20 @@ function broadcast(delta) {
 // ─── Elements ──────────────────────────────────────────────────────────────
 
 function createElement(partial) {
+  hooks.emit('beforeElementCreate', partial)
   const now = Date.now()
+  // Use the registered element type's default size when the caller didn't
+  // pass an explicit width/height. Without this lookup the registry values
+  // are ignored at runtime and every untyped caller falls back to 160×80
+  // regardless of what the type definition declared.
+  const typeDef = getElementType(partial.type)
   const el = {
     id:            randomUUID(),
     type:          partial.type,
     x:             partial.x ?? 0,
     y:             partial.y ?? 0,
-    width:         partial.width ?? 160,
-    height:        partial.height ?? 80,
+    width:         partial.width  ?? typeDef?.defaultWidth  ?? 160,
+    height:        partial.height ?? typeDef?.defaultHeight ?? 80,
     data:          partial.data ?? {},
     zoneId:        partial.zoneId ?? null,
     expansionMode: partial.expansionMode ?? 'inline',
@@ -80,46 +88,51 @@ function createElement(partial) {
   dbInsertElement(el)
   elements.set(el.id, el)
   broadcast({ type: 'element:add', element: el })
+  hooks.emit('afterElementCreate', el)
   return el
 }
 
 function updateElement(id, changes) {
+  hooks.emit('beforeElementUpdate', id, changes)
   const existing = elements.get(id)
   if (!existing) throw new Error(`Element not found: ${id}`)
   const updated = { ...existing, ...changes, id, updatedAt: Date.now() }
   dbUpdateElement(id, updated)
   elements.set(id, updated)
   broadcast({ type: 'element:update', id, changes: { ...changes, updatedAt: updated.updatedAt } })
+  hooks.emit('afterElementUpdate', id, updated)
   return updated
 }
 
 function removeElement(id) {
+  hooks.emit('beforeElementRemove', id)
   const el = elements.get(id)
   if (!el) throw new Error(`Element not found: ${id}`)
   const item = { id, elementData: el, timestamp: Date.now() }
   dbInsertDeleted(item)
   dbDeleteElement(id)
   elements.delete(id)
-  // Remove associated links from memory (DB cascade handles DB)
   for (const [lid, link] of links) {
     if (link.fromElementId === id || link.toElementId === id) links.delete(lid)
   }
   broadcast({ type: 'element:remove', id })
+  hooks.emit('afterElementRemove', id, item)
   return item
 }
 
 function archiveElement(id) {
+  hooks.emit('beforeElementArchive', id)
   const el = elements.get(id)
   if (!el) throw new Error(`Element not found: ${id}`)
   const item = { id, elementData: el, timestamp: Date.now() }
   dbInsertArchive(item)
   dbDeleteElement(id)
   elements.delete(id)
-  // Remove associated links from memory (DB cascade handles DB)
   for (const [lid, link] of links) {
     if (link.fromElementId === id || link.toElementId === id) links.delete(lid)
   }
   broadcast({ type: 'element:remove', id })
+  hooks.emit('afterElementArchive', id, item)
   return item
 }
 
@@ -137,17 +150,20 @@ function duplicateElement(id, offsetX = 40, offsetY = 40) {
 }
 
 function updateElementState(id, state) {
+  hooks.emit('beforeElementStateChange', id, state)
   const el = elements.get(id)
   if (!el) return
   el.state = state
   el.updatedAt = Date.now()
   dbUpdateElement(id, el)
   broadcast({ type: 'element:state', id, state })
+  hooks.emit('afterElementStateChange', id, state)
 }
 
 // ─── Links ─────────────────────────────────────────────────────────────────
 
 function createLink(partial) {
+  hooks.emit('beforeLinkCreate', partial)
   if (!elements.has(partial.fromElementId)) throw new Error(`Source element not found: ${partial.fromElementId}`)
   if (!elements.has(partial.toElementId))   throw new Error(`Target element not found: ${partial.toElementId}`)
 
@@ -163,20 +179,24 @@ function createLink(partial) {
   dbInsertLink(link)
   links.set(link.id, link)
   broadcast({ type: 'link:add', link })
+  hooks.emit('afterLinkCreate', link)
   return link
 }
 
 function removeLink(id) {
+  hooks.emit('beforeLinkRemove', id)
   const link = links.get(id)
   if (!link) throw new Error(`Link not found: ${id}`)
   dbDeleteLink(id)
   links.delete(id)
   broadcast({ type: 'link:remove', id })
+  hooks.emit('afterLinkRemove', id)
 }
 
 // ─── Zones ─────────────────────────────────────────────────────────────────
 
 function createZone(partial) {
+  hooks.emit('beforeZoneCreate', partial)
   const now = Date.now()
   const zone = {
     id:        randomUUID(),
@@ -194,30 +214,36 @@ function createZone(partial) {
   dbInsertZone(zone)
   zones.set(zone.id, zone)
   broadcast({ type: 'zone:add', zone })
+  hooks.emit('afterZoneCreate', zone)
   return zone
 }
 
 function updateZone(id, changes) {
+  hooks.emit('beforeZoneUpdate', id, changes)
   const existing = zones.get(id)
   if (!existing) throw new Error(`Zone not found: ${id}`)
   const updated = { ...existing, ...changes, id, updatedAt: Date.now() }
   dbUpdateZone(id, updated)
   zones.set(id, updated)
   broadcast({ type: 'zone:update', id, changes: { ...changes, updatedAt: updated.updatedAt } })
+  hooks.emit('afterZoneUpdate', id, updated)
   return updated
 }
 
 function removeZone(id) {
+  hooks.emit('beforeZoneRemove', id)
   const zone = zones.get(id)
   if (!zone) throw new Error(`Zone not found: ${id}`)
   dbDeleteZone(id)
   zones.delete(id)
   broadcast({ type: 'zone:remove', id })
+  hooks.emit('afterZoneRemove', id)
 }
 
 // ─── Views ─────────────────────────────────────────────────────────────────
 
 function createView(partial) {
+  hooks.emit('beforeViewCreate', partial)
   const view = {
     id:        randomUUID(),
     name:      partial.name || 'View',
@@ -229,15 +255,18 @@ function createView(partial) {
   dbInsertView(view)
   views.set(view.id, view)
   broadcast({ type: 'view:add', view })
+  hooks.emit('afterViewCreate', view)
   return view
 }
 
 function removeView(id) {
+  hooks.emit('beforeViewRemove', id)
   const view = views.get(id)
   if (!view) throw new Error(`View not found: ${id}`)
   dbDeleteView(id)
   views.delete(id)
   broadcast({ type: 'view:remove', id })
+  hooks.emit('afterViewRemove', id)
 }
 
 // ─── Archive / Deleted bins ────────────────────────────────────────────────
@@ -277,6 +306,7 @@ function setMeta(key, value) { dbSetMeta(key, value) }
 // ─── Shapes ─────────────────────────────────────────────────────────────────
 
 function createShape(partial) {
+  hooks.emit('beforeShapeCreate', partial)
   const now = Date.now()
   const s = {
     id:          randomUUID(),
@@ -297,25 +327,30 @@ function createShape(partial) {
   dbInsertShape(s)
   shapes.set(s.id, s)
   broadcast({ type: 'shape:add', shape: s })
+  hooks.emit('afterShapeCreate', s)
   return s
 }
 
 function updateShape(id, changes) {
+  hooks.emit('beforeShapeUpdate', id, changes)
   const existing = shapes.get(id)
   if (!existing) throw new Error(`Shape not found: ${id}`)
   const updated = { ...existing, ...changes, id, updatedAt: Date.now() }
   dbUpdateShape(id, updated)
   shapes.set(id, updated)
   broadcast({ type: 'shape:update', id, changes: { ...changes, updatedAt: updated.updatedAt } })
+  hooks.emit('afterShapeUpdate', id, updated)
   return updated
 }
 
 function removeShape(id) {
+  hooks.emit('beforeShapeRemove', id)
   const s = shapes.get(id)
   if (!s) throw new Error(`Shape not found: ${id}`)
   dbDeleteShape(id)
   shapes.delete(id)
   broadcast({ type: 'shape:remove', id })
+  hooks.emit('afterShapeRemove', id)
 }
 
 // ─── Read helpers for ElementContext ───────────────────────────────────────

package/server/utils/config.js

@@ -34,6 +34,7 @@ try {
 } catch (_) {}
 
 const STUDIO_SECRET = process.env.STUDIO_SECRET || studioConfig.secret || ''
+const STUDIO_EXTENSIONS_CONFIG = studioConfig.extensions ?? {}
 
 const DB_PATH = path.join(PROJECT_DIR, '.veil-studio', 'studio.db')
 const ELEMENTS_DIR = path.join(PROJECT_DIR, '.veil-studio', 'elements')
@@ -48,4 +49,5 @@ module.exports = {
   DB_PATH,
   ELEMENTS_DIR,
   VEIL_WS_URL,
+  STUDIO_EXTENSIONS_CONFIG,
 }

package/server/utils/element-hooks.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { EventEmitter } = require('events')
+
+/**
+ * Element instance lifecycle hooks.
+ *
+ * Events:
+ *   afterInstanceCreated(elementId, instance, element)
+ *   afterInstanceDestroyed(elementId)
+ *   beforeActionInvoked(elementId, action, params)
+ *   afterActionInvoked(elementId, action, params, result)
+ */
+const hooks = new EventEmitter()
+hooks.setMaxListeners(50)
+
+module.exports = hooks

package/server/utils/element-instances.js

@@ -4,6 +4,7 @@ const { getElementType } = require('./element-registry.js')
 const boardState = require('./board-state.js')
 const { veilGet, veilPost, veilPut, veilDelete } = require('./veil-client.js')
 const { getIO } = require('./socket-io.js')
+const hooks = require('./element-hooks.js')
 
 const instances = new Map()
 
@@ -37,6 +38,7 @@ function createInstance(element) {
     const ctx = _buildContext(element)
     const instance = def.createInstance(ctx)
     instances.set(element.id, instance)
+    hooks.emit('afterInstanceCreated', element.id, instance, element)
     return instance
   } catch (err) {
     console.error(`[element-instances] Failed to create instance for ${element.type}:${element.id}:`, err.message)
@@ -57,6 +59,7 @@ async function destroyInstance(elementId) {
     console.error(`[element-instances] onDestroy error for ${elementId}:`, err.message)
   }
   instances.delete(elementId)
+  hooks.emit('afterInstanceDestroyed', elementId)
 }
 
 async function invokeAction(elementId, action, params) {
@@ -65,7 +68,10 @@ async function invokeAction(elementId, action, params) {
   if (!instance.actions || typeof instance.actions[action] !== 'function') {
     throw new Error(`Action "${action}" not found on element ${elementId}`)
   }
-  return instance.actions[action](params)
+  hooks.emit('beforeActionInvoked', elementId, action, params)
+  const result = await instance.actions[action](params)
+  hooks.emit('afterActionInvoked', elementId, action, params, result)
+  return result
 }
 
 function getViewData(elementId) {
@@ -80,8 +86,8 @@ function getPorts(elementId) {
   try { return instance.getPorts() } catch (_) { return [] }
 }
 
-function recreateInstance(element) {
-  destroyInstance(element.id)
+async function recreateInstance(element) {
+  await destroyInstance(element.id)
   return createInstance(element)
 }
 

package/server/utils/element-registry.js

@@ -96,8 +96,8 @@ function getClientComponentDefinitions() {
 const ELEMENTS_SERVER_DIR = path.join(__dirname, 'elements')
 
 const BUILTIN_TYPES = [
-  'agent', 'agent-instance', 'chat-view', 'task', 'todo-list',
-  'text', 'markdown', 'code-block', 'json-object', 'html', 'file-reference', 'image', 'image-local', 'url-card', 'web-snapshot',
+  'agent', 'agent-instance', 'chat-view', 'task', 'terminal', 'todo-list',
+  'text', 'markdown', 'code-block', 'json-object', 'html', 'web-preview', 'file-reference', 'image', 'image-local', 'url-card', 'web-snapshot',
   'source-collection', 'research-note', 'comparison-table', 'fact-claim', 'question', 'web-search-query',
   'document-draft', 'outline', 'section', 'template',
   'diff-patch', 'notification', 'test-case',

package/server/utils/elements/agent-instance.js

@@ -5,8 +5,8 @@ module.exports = {
   name:          'Agent Instance',
   description:   'An active chat session with a VeilCLI agent.',
   icon:          'message-circle',
-  defaultWidth:  180,
-  defaultHeight: 90,
+  defaultWidth:  260,
+  defaultHeight: 160,
   expansionMode: 'sidebar',
   tags:              ['cli', 'agent', 'chat'],
   isBuiltIn:         true,

package/server/utils/elements/agent.js

@@ -59,8 +59,6 @@ module.exports = {
             type:   'agent-instance',
             x:      element.x + 200,
             y:      element.y,
-            width:  180,
-            height: 110,
             data:   { agentName, sessionId },
           })
 

package/server/utils/elements/chat-view.js

@@ -5,8 +5,8 @@ module.exports = {
   name:              'Chat View',
   description:       'Inline chat panel for an agent session. Created automatically from an agent instance.',
   icon:              '💬',
-  defaultWidth:      320,
-  defaultHeight:     440,
+  defaultWidth:      400,
+  defaultHeight:     450,
   hiddenFromPalette: true,
   tags:              ['cli'],
   isBuiltIn:         true,

package/server/utils/elements/html.js

@@ -2,8 +2,8 @@
 
 module.exports = {
   type:          'html',
-  name:          'HTML Preview',
-  description:   'Write HTML in edit mode, preview it live via a sandboxed iframe.',
+  name:          'HTML Code Preview',
+  description:   'Write HTML code in edit mode, preview it live via a sandboxed iframe.',
   icon:          'code-tags',
   defaultWidth:  320,
   defaultHeight: 240,

package/server/utils/elements/terminal.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const terminalManager = require('../terminal-manager.js')
+
+module.exports = {
+  type:          'terminal',
+  name:          'Terminal',
+  description:   'Integrated terminal — runs a live shell session',
+  icon:          'mdi-console',
+  defaultWidth:  560,
+  defaultHeight: 340,
+  expansionMode: 'inline',
+  tags:          ['cli', 'dev'],
+  isBuiltIn:     true,
+
+  createInstance({ element }) {
+    const terminalId = element.id
+
+    return {
+      getViewData() {
+        return {
+          terminalId,
+          pid:    terminalManager.getPID(terminalId),
+          exited: terminalManager.isExited(terminalId),
+        }
+      },
+
+      getPorts() { return [] },
+
+      // Terminal is driven via terminal:* socket events — no element:action needed
+      actions: {},
+
+      onDestroy() {
+        terminalManager.destroyPTY(terminalId)
+      },
+    }
+  },
+}

package/server/utils/elements/web-preview.js

@@ -0,0 +1,31 @@
+'use strict'
+
+module.exports = {
+  type:          'web-preview',
+  name:          'Web Preview',
+  description:   'Render a project HTML file in an iframe with auto-refresh on file change.',
+  icon:          'globe',
+  defaultWidth:  400,
+  defaultHeight: 250,
+  tags:          ['data', 'dev'],
+  isBuiltIn:     true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        // isHidden / isKilled are NOT exposed via viewData — the server only
+        // re-pushes viewData on creation / streaming changes, so a stale
+        // viewData snapshot would mask later element.data updates. The Vue
+        // component reads those flags from element.data directly instead.
+        return {
+          filePath: element.data.filePath || '',
+        }
+      },
+      getPorts() {
+        return []
+      },
+      actions: {},
+    }
+  },
+}

package/server/utils/file-utils.js

@@ -2,14 +2,31 @@
 
 const path = require('path')
 const fs = require('fs')
+const { execSync } = require('child_process')
 const { PROJECT_DIR } = require('./config.js')
 
 const EXCLUDED_NAMES = new Set(['node_modules', '.git', '.nuxt', '.output', '.cache'])
+
+// ── Per-file write lock (serialize concurrent writes to the same path) ──────
+const _locks = new Map()  // relativePath -> Promise
+
+function acquireLock(relativePath) {
+  const prev = _locks.get(relativePath) || Promise.resolve()
+  let release
+  const lock = new Promise(resolve => { release = resolve })
+  _locks.set(relativePath, prev.then(() => lock))
+  return prev.then(() => release)
+}
 const MAX_DEPTH = 6
 
 function _safePath(relativePath) {
   const resolved = path.resolve(PROJECT_DIR, relativePath)
-  if (!resolved.startsWith(PROJECT_DIR)) {
+  // Guard against sibling-directory bypass: a plain `startsWith(PROJECT_DIR)`
+  // accepts paths like `<PROJECT_DIR>_evil/...` because the prefix happens to
+  // match. Compare with the trailing separator (or exact equality for the dir
+  // itself) so only true descendants pass.
+  const allowed = resolved === PROJECT_DIR || resolved.startsWith(PROJECT_DIR + path.sep)
+  if (!allowed) {
     const err = new Error(`Access denied: path outside PROJECT_DIR`)
     err.status = 403
     throw err
@@ -19,30 +36,77 @@ function _safePath(relativePath) {
 
 function buildFileTree(dir = PROJECT_DIR, depth = 0) {
   if (depth >= MAX_DEPTH) return []
-  const entries = fs.readdirSync(dir, { withFileTypes: true })
-  const result = []
+  let entries
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return [] }
+  const dirs  = []
+  const files = []
   for (const entry of entries) {
     if (EXCLUDED_NAMES.has(entry.name)) continue
     const fullPath = path.join(dir, entry.name)
-    const relPath = path.relative(PROJECT_DIR, fullPath)
-    if (entry.isDirectory()) {
-      result.push({
-        name:     entry.name,
-        path:     relPath,
-        type:     'directory',
-        children: buildFileTree(fullPath, depth + 1),
-      })
-    } else {
+    const relPath  = path.relative(PROJECT_DIR, fullPath)
+    try {
       const stat = fs.statSync(fullPath)
-      result.push({
-        name: entry.name,
-        path: relPath,
-        type: 'file',
-        size: stat.size,
-      })
+      if (entry.isDirectory()) {
+        dirs.push({
+          name:     entry.name,
+          path:     relPath,
+          type:     'directory',
+          mtime:    stat.mtimeMs,
+          children: buildFileTree(fullPath, depth + 1),
+        })
+      } else {
+        files.push({
+          name:  entry.name,
+          path:  relPath,
+          type:  'file',
+          size:  stat.size,
+          mtime: stat.mtimeMs,
+        })
+      }
+    } catch { /* skip inaccessible entries */ }
+  }
+  dirs.sort((a, b) => a.name.localeCompare(b.name))
+  files.sort((a, b) => a.name.localeCompare(b.name))
+  return [...dirs, ...files]
+}
+
+function getGitStatus() {
+  try {
+    const output = execSync('git status --porcelain', {
+      cwd:      PROJECT_DIR,
+      timeout:  3000,
+      encoding: 'utf8',
+    })
+    const result = {}
+    for (const line of output.split('\n')) {
+      if (!line.trim()) continue
+      const x = line[0]
+      const y = line[1]
+      let filePath = line.slice(3).trim()
+      // Renamed: "old -> new"
+      if (filePath.includes(' -> ')) filePath = filePath.split(' -> ')[1]
+      // Quoted paths
+      if (filePath.startsWith('"')) filePath = filePath.slice(1, -1)
+      // Strip trailing slash (git marks untracked dirs with "/" e.g. "?? .veil/")
+      if (filePath.endsWith('/')) filePath = filePath.slice(0, -1)
+      if (x === '?' && y === '?') {
+        result[filePath] = 'U'
+      } else if (x === 'D' || y === 'D') {
+        result[filePath] = 'D'
+      } else if (x === 'R' || y === 'R') {
+        result[filePath] = 'R'
+      } else {
+        result[filePath] = 'M'
+      }
     }
+    return result
+  } catch {
+    return null  // not a git repo or git not available
   }
-  return result
+}
+
+function getProjectFilePath(relativePath) {
+  return _safePath(relativePath)
 }
 
 function readProjectFile(relativePath) {
@@ -69,7 +133,7 @@ function renameProjectFile(fromRel, toRel) {
 }
 
 function deleteProjectPath(relativePath) {
-  const abs = _safePath(relativePath)
+  const abs  = _safePath(relativePath)
   const stat = fs.statSync(abs)
   if (stat.isDirectory()) {
     fs.rmSync(abs, { recursive: true, force: true })
@@ -78,11 +142,21 @@ function deleteProjectPath(relativePath) {
   }
 }
 
+function writeProjectFileBuffer(relativePath, buffer) {
+  const abs = _safePath(relativePath)
+  fs.mkdirSync(path.dirname(abs), { recursive: true })
+  fs.writeFileSync(abs, buffer)
+}
+
 module.exports = {
   buildFileTree,
+  getGitStatus,
+  getProjectFilePath,
   readProjectFile,
   writeProjectFile,
+  writeProjectFileBuffer,
   createProjectDir,
   renameProjectFile,
   deleteProjectPath,
+  acquireLock,
 }

package/server/utils/file-watcher.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const path = require('path')
+const { watch } = require('chokidar')
+const { PROJECT_DIR, ELEMENTS_DIR } = require('./config.js')
+const { getIO } = require('./socket-io.js')
+
+let _watcher = null
+
+const IGNORED = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/.nuxt/**',
+  '**/.output/**',
+  '**/.cache/**',
+  '**/studio.db',
+  '**/studio.db-journal',
+  '**/studio.db-wal',
+]
+
+// ── Suppress: prevent double-notification for Studio-initiated mutations ────
+const _suppressed = new Set()
+
+function suppressPath(relPath) {
+  _suppressed.add(relPath)
+  setTimeout(() => _suppressed.delete(relPath), 1000)
+}
+
+// ── Debounce: batch rapid events into a single emission ─────────────────────
+const _pending = new Map()
+const DEBOUNCE_MS = 300
+
+function _emitChange(eventType, relPath) {
+  if (_suppressed.has(relPath)) {
+    _suppressed.delete(relPath)
+    return
+  }
+
+  const existing = _pending.get(relPath)
+  if (existing) clearTimeout(existing.timeout)
+
+  _pending.set(relPath, {
+    type: eventType,
+    timeout: setTimeout(() => {
+      _pending.delete(relPath)
+      try {
+        getIO().emit('files:changed', { type: eventType, path: relPath })
+      } catch (_) { /* IO not ready yet */ }
+
+      if (_isElementsPath(relPath)) {
+        try { getIO().emit('files:elements-changed') } catch (_) {}
+      }
+    }, DEBOUNCE_MS),
+  })
+}
+
+function _isElementsPath(relPath) {
+  const elementsRel = path.relative(PROJECT_DIR, ELEMENTS_DIR)
+  return relPath.startsWith(elementsRel + path.sep) || relPath === elementsRel
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+function startFileWatcher() {
+  if (_watcher) return
+
+  _watcher = watch(PROJECT_DIR, {
+    ignored: IGNORED,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+    depth: 10,
+  })
+
+  _watcher
+    .on('add',       (abs) => _emitChange('add',       path.relative(PROJECT_DIR, abs)))
+    .on('change',    (abs) => _emitChange('change',    path.relative(PROJECT_DIR, abs)))
+    .on('unlink',    (abs) => _emitChange('unlink',    path.relative(PROJECT_DIR, abs)))
+    .on('addDir',    (abs) => _emitChange('addDir',    path.relative(PROJECT_DIR, abs)))
+    .on('unlinkDir', (abs) => _emitChange('unlinkDir', path.relative(PROJECT_DIR, abs)))
+    .on('error',     (err) => console.error('[file-watcher] Error:', err.message))
+
+  console.log('  File watcher active')
+}
+
+function stopFileWatcher() {
+  if (_watcher) {
+    _watcher.close()
+    _watcher = null
+  }
+}
+
+module.exports = { startFileWatcher, stopFileWatcher, suppressPath }