@newsails/veil-studio 1.0.0

package/server/routes/files.js

@@ -0,0 +1,80 @@
+'use strict'
+
+const router = require('express').Router()
+const {
+  buildFileTree,
+  readProjectFile,
+  writeProjectFile,
+  createProjectDir,
+  renameProjectFile,
+  deleteProjectPath,
+} = require('../utils/file-utils.js')
+
+function handleError(res, err) {
+  const status = err.status || 500
+  res.status(status).json({ error: err.message })
+}
+
+router.get('/tree', (req, res) => {
+  try {
+    res.json(buildFileTree())
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+router.get('/content', (req, res) => {
+  try {
+    const { path: filePath } = req.query
+    if (!filePath) return res.status(400).json({ error: 'path query param required' })
+    res.json({ content: readProjectFile(filePath) })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+router.put('/content', (req, res) => {
+  try {
+    const { path: filePath, content } = req.body
+    if (!filePath) return res.status(400).json({ error: 'path required' })
+    writeProjectFile(filePath, content ?? '')
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+router.post('/mkdir', (req, res) => {
+  try {
+    const { path: dirPath } = req.body
+    if (!dirPath) return res.status(400).json({ error: 'path required' })
+    createProjectDir(dirPath)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+router.post('/rename', (req, res) => {
+  try {
+    const { from, to } = req.body
+    if (!from || !to) return res.status(400).json({ error: 'from and to required' })
+    renameProjectFile(from, to)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+router.post('/delete', (req, res) => {
+  try {
+    const { path: targetPath } = req.body
+    if (!targetPath) return res.status(400).json({ error: 'path required' })
+    deleteProjectPath(targetPath)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+module.exports = router

package/server/socket.js

@@ -0,0 +1,507 @@
+'use strict'
+
+const boardState = require('./utils/board-state.js')
+const { isVeilConnected } = require('./utils/veil-ws.js')
+const { getAllTypes, getElementType, reloadCustomElements } = require('./utils/element-registry.js')
+const { getInstance, invokeAction, initAllInstances, destroyInstance, createInstance, getViewData, getPorts } = require('./utils/element-instances.js')
+const { getIO } = require('./utils/socket-io.js')
+const {
+  veilGet, veilPost, veilPut, veilDelete, veilStreamChat,
+} = require('./utils/veil-client.js')
+const { setActiveStreamsRef, setElementStreamingRef } = require('./utils/veil-ws.js')
+const { touchSession } = require('./utils/session-watcher.js')
+
+const _activeStreams = new Map() // sessionId → { stopped: boolean } — shared across all socket connections
+setActiveStreamsRef(_activeStreams)
+setElementStreamingRef(_setElementStreaming)
+
+function _setElementStreaming(sessionId, streaming) {
+  const elements = boardState.getElements().filter(e => e.data?.sessionId === sessionId)
+  for (const el of elements) {
+    try {
+      const instance = getInstance(el.id)
+      if (instance?.actions?.setStreaming) {
+        instance.actions.setStreaming({ streaming })
+        const viewData = getViewData(el.id)
+        const ports    = getPorts(el.id)
+        getIO().to('board').emit('board:delta', { type: 'element:view', id: el.id, viewData: { ...viewData, ports } })
+      }
+    } catch (err) {
+      console.error('[_setElementStreaming] Error:', err.message)
+    }
+  }
+}
+
+function registerSocketHandlers(io) {
+  io.on('connection', (socket) => {
+    // Join board room + send initial state
+    socket.join('board')
+    socket.emit('board:init', { snapshot: boardState.getSnapshot() })
+    socket.emit('veil:status', { connected: isVeilConnected() })
+    socket.emit('element-types:update', { types: getAllTypes() })
+
+    // Send initial element view data + ports for all elements
+    for (const el of boardState.getElements()) {
+      const viewData = getViewData(el.id)
+      const ports    = getPorts(el.id)
+      if (Object.keys(viewData).length > 0 || ports.length > 0) {
+        socket.emit('board:delta', { type: 'element:view', id: el.id, viewData: { ...viewData, ports } })
+      }
+    }
+
+    // ─── Board Actions ──────────────────────────────────────────────────────
+
+    socket.on('board:action', (payload, ack) => {
+      try {
+        _handleBoardAction(payload)
+        if (typeof ack === 'function') ack({ ok: true })
+      } catch (err) {
+        console.error('[board:action] Error:', err.message)
+        if (typeof ack === 'function') ack({ error: err.message })
+      }
+    })
+
+    socket.on('board:get-archive', (_, ack) => {
+      if (typeof ack === 'function') ack({ items: boardState.getArchive() })
+    })
+
+    socket.on('board:get-deleted', (_, ack) => {
+      if (typeof ack === 'function') ack({ items: boardState.getDeleted() })
+    })
+
+    socket.on('board:restore-archive', ({ id } = {}, ack) => {
+      try {
+        const el = boardState.restoreFromArchive(id)
+        _createInstanceAndBroadcast(el)
+        if (typeof ack === 'function') ack({ ok: true, element: el })
+      } catch (err) {
+        if (typeof ack === 'function') ack({ error: err.message })
+      }
+    })
+
+    socket.on('board:add-agent-instance', async ({ agentName, x, y } = {}, ack) => {
+      try {
+        if (!agentName) throw new Error('agentName is required')
+        const res = await veilPost('/sessions', { agentName })
+        const sessionId = res.sessionId || res.id || res.session_id
+        if (!sessionId) throw new Error('No sessionId returned from Veil API')
+        const el = boardState.createElement({ type: 'agent-instance', x: x ?? 200, y: y ?? 200, width: 180, height: 120, data: { agentName, sessionId } })
+        _createInstanceAndBroadcast(el)
+        if (typeof ack === 'function') ack({ ok: true, elementId: el.id, sessionId })
+      } catch (err) {
+        console.error('[board:add-agent-instance] Error:', err.message)
+        if (typeof ack === 'function') ack({ error: err.message })
+      }
+    })
+
+    socket.on('board:restore-deleted', ({ id } = {}, ack) => {
+      try {
+        const el = boardState.restoreFromDeleted(id)
+        _createInstanceAndBroadcast(el)
+        if (typeof ack === 'function') ack({ ok: true, element: el })
+      } catch (err) {
+        if (typeof ack === 'function') ack({ error: err.message })
+      }
+    })
+
+    // ─── Element Actions ────────────────────────────────────────────────────
+
+    socket.on('element:action', async ({ elementId, action, params } = {}, ack) => {
+      try {
+        const result = await invokeAction(elementId, action, params)
+        if (typeof ack === 'function') ack({ ok: true, result })
+      } catch (err) {
+        console.error('[element:action] Error:', err.message)
+        if (typeof ack === 'function') ack({ error: err.message })
+      }
+    })
+
+    socket.on('element:reload-custom', async (_, ack) => {
+      try {
+        // Destroy instances for elements whose type is currently a custom type
+        for (const el of boardState.getElements()) {
+          const def = getElementType(el.type)
+          if (def && !def.isBuiltIn) await destroyInstance(el.id)
+        }
+        reloadCustomElements()
+        initAllInstances()
+        const types = getAllTypes()
+        io.emit('element-types:update', { types })
+        if (typeof ack === 'function') ack({ ok: true, types })
+      } catch (err) {
+        if (typeof ack === 'function') ack({ error: err.message })
+      }
+    })
+
+    // ─── Chat Streaming ─────────────────────────────────────────────────────
+
+    socket.on('chat:send', async ({ agentName, sessionId, message } = {}) => {
+      const ctrl = { stopped: false }
+      _activeStreams.set(sessionId, ctrl)
+      // Broadcast user message to all clients immediately so every tab sees it
+      getIO().to('board').emit('chat:user-message', { sessionId, agentName, message })
+      // Mark element as streaming so all clients can reflect the loading state
+      _setElementStreaming(sessionId, true)
+      try {
+        let lastMessage = null
+        let tokenUsage = null
+        const io = getIO()
+        for await (const chunk of veilStreamChat(agentName, message, sessionId)) {
+          if (ctrl.stopped) break
+          io.to('board').emit('chat:stream', { sessionId, eventType: chunk.eventType, data: chunk.data })
+          if (chunk.eventType === 'message') lastMessage = chunk.data
+          if (chunk.data && chunk.data.token_usage) tokenUsage = chunk.data.token_usage
+        }
+        if (!ctrl.stopped) {
+          io.to('board').emit('chat:done', { sessionId, message: lastMessage, tokenUsage })
+        } else {
+          io.to('board').emit('chat:done', { sessionId, message: null, tokenUsage: null })
+        }
+      } catch (err) {
+        console.error('[chat:send] Error:', err.message)
+        getIO().to('board').emit('chat:error', { sessionId, error: err.message })
+      } finally {
+        _activeStreams.delete(sessionId)
+        // Mark element as no longer streaming
+        _setElementStreaming(sessionId, false)
+        // Advance message baseline so the next external syncSession skips these messages
+        touchSession(sessionId).catch(() => {})
+      }
+    })
+
+    socket.on('chat:stop', ({ sessionId } = {}) => {
+      const ctrl = _activeStreams.get(sessionId)
+      if (ctrl) ctrl.stopped = true
+    })
+
+    // ─── VeilCLI Proxy Events ─────────────────────────────────────────────
+
+    // Agents
+    socket.on('veil:get-agents', async (_, ack) => {
+      try {
+        const result = await veilGet('/agents')
+        ack({ agents: Array.isArray(result) ? result : (result.agents ?? []) })
+      }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:create-agent', async ({ data } = {}, ack) => {
+      try { ack({ agent: await veilPost('/agents', data) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:get-agent', async ({ name } = {}, ack) => {
+      try { ack({ agent: await veilGet(`/agents/${encodeURIComponent(name)}`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:update-agent', async ({ name, data } = {}, ack) => {
+      try { ack({ agent: await veilPut(`/agents/${encodeURIComponent(name)}`, data) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:delete-agent', async ({ name } = {}, ack) => {
+      try { ack({ ok: true, result: await veilDelete(`/agents/${encodeURIComponent(name)}`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:reload-agent', async ({ name } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPost(`/agents/${encodeURIComponent(name)}/reload`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:get-agent-skills', async ({ name } = {}, ack) => {
+      try { ack({ skills: await veilGet(`/agents/${encodeURIComponent(name)}/skills`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    // Sessions
+    socket.on('veil:get-sessions', async ({ agentName } = {}, ack) => {
+      try {
+        const q = agentName ? { agent: agentName } : {}
+        ack({ sessions: await veilGet('/sessions', q) })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:create-session', async ({ agentName } = {}, ack) => {
+      try {
+        const session = await veilPost('/sessions', { agentName })
+        ack({ session })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:get-session', async ({ id } = {}, ack) => {
+      try { ack({ session: await veilGet(`/sessions/${encodeURIComponent(id)}`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:delete-session', async ({ id } = {}, ack) => {
+      try { ack({ ok: true, result: await veilDelete(`/sessions/${encodeURIComponent(id)}`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:get-session-messages', async ({ id } = {}, ack) => {
+      try {
+        const [msgRes, sessionRes] = await Promise.all([
+          veilGet(`/sessions/${encodeURIComponent(id)}/messages`),
+          veilGet(`/sessions/${encodeURIComponent(id)}`).catch(() => null),
+        ])
+        ack({
+          messages: Array.isArray(msgRes) ? msgRes : (msgRes.messages ?? []),
+          session:  sessionRes,
+        })
+      }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:reset-session', async ({ id } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPost(`/sessions/${encodeURIComponent(id)}/reset`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    // Tasks
+    socket.on('veil:create-task', async ({ agentName, prompt } = {}, ack) => {
+      try { ack({ task: await veilPost('/tasks', { agent: agentName, prompt }) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:get-tasks', async ({ agentName } = {}, ack) => {
+      try {
+        const q = agentName ? { agent: agentName } : {}
+        ack({ tasks: await veilGet('/tasks', q) })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:get-task', async ({ id } = {}, ack) => {
+      try { ack({ task: await veilGet(`/tasks/${encodeURIComponent(id)}`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:cancel-task', async ({ id } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPost(`/tasks/${encodeURIComponent(id)}/cancel`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:respond-task', async ({ id, message } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPost(`/tasks/${encodeURIComponent(id)}/respond`, { message }) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    // Daemons
+    socket.on('veil:get-daemons', async (_, ack) => {
+      try { ack({ daemons: await veilGet('/daemons') }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:daemon-start', async ({ agentName } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPost(`/daemons/${encodeURIComponent(agentName)}/start`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:daemon-stop', async ({ agentName } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPost(`/daemons/${encodeURIComponent(agentName)}/stop`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:daemon-trigger', async ({ agentName } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPost(`/daemons/${encodeURIComponent(agentName)}/trigger`) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    // Memory
+    socket.on('veil:get-memory', async ({ agentName, level } = {}, ack) => {
+      try {
+        const path = (level === 'global' || !agentName)
+          ? '/memory'
+          : `/agents/${encodeURIComponent(agentName)}/memory`
+        const res = await veilGet(path)
+        ack({ files: res.files ?? [] })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:get-memory-file', async ({ agentName, file, level } = {}, ack) => {
+      try {
+        const path = (level === 'global' || !agentName)
+          ? `/memory/${encodeURIComponent(file)}`
+          : `/agents/${encodeURIComponent(agentName)}/memory/${encodeURIComponent(file)}`
+        const res = await veilGet(path)
+        ack({ content: res.content ?? '' })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:update-memory-file', async ({ agentName, file, content, level } = {}, ack) => {
+      try {
+        const path = (level === 'global' || !agentName)
+          ? `/memory/${encodeURIComponent(file)}`
+          : `/agents/${encodeURIComponent(agentName)}/memory/${encodeURIComponent(file)}`
+        ack({ ok: true, result: await veilPut(path, { content }) })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:delete-memory-file', async ({ agentName, file, level } = {}, ack) => {
+      try {
+        const path = (level === 'global' || !agentName)
+          ? `/memory/${encodeURIComponent(file)}`
+          : `/agents/${encodeURIComponent(agentName)}/memory/${encodeURIComponent(file)}`
+        ack({ ok: true, result: await veilDelete(path) })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    // Models
+    socket.on('veil:get-models', async (_, ack) => {
+      try { ack({ models: await veilGet('/models') }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    // Agent AGENT.md — read from disk via agentFolder returned by GET /agents/:name
+    socket.on('veil:get-agent-md', async ({ name } = {}, ack) => {
+      try {
+        const fs   = require('fs')
+        const path = require('path')
+        const agentRes = await veilGet(`/agents/${encodeURIComponent(name)}`)
+        const agentData = agentRes.agent ?? agentRes
+        const folder = agentData.agentFolder
+        if (!folder) { ack({ content: '' }); return }
+        const mdPath = path.join(folder, 'AGENT.md')
+        const content = fs.existsSync(mdPath) ? fs.readFileSync(mdPath, 'utf8') : ''
+        ack({ content })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
+    // Settings
+    socket.on('veil:get-settings', async (_, ack) => {
+      try { ack({ settings: await veilGet('/settings') }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+
+    socket.on('veil:update-settings', async ({ settings } = {}, ack) => {
+      try { ack({ ok: true, result: await veilPut('/settings', settings) }) }
+      catch (err) { ack({ error: err.message }) }
+    })
+  })
+}
+
+// ─── Board Action Dispatch ──────────────────────────────────────────────────
+
+function _handleBoardAction(payload) {
+  const { type, id, payload: data = {} } = payload
+
+  switch (type) {
+    case 'element:add': {
+      const { type: elType, x, y, data: elData } = data
+      const el = boardState.createElement({ type: elType, x, y, data: elData })
+      _createInstanceAndBroadcast(el)
+      break
+    }
+    case 'element:move':
+      boardState.updateElement(id, { x: data.x, y: data.y })
+      break
+
+    case 'element:resize':
+      boardState.updateElement(id, { width: data.width, height: data.height })
+      break
+
+    case 'element:expand':
+      boardState.updateElement(id, { expanded: true })
+      break
+
+    case 'element:collapse':
+      boardState.updateElement(id, { expanded: false })
+      break
+
+    case 'element:delete':
+      boardState.removeElement(id)
+      break
+
+    case 'element:archive':
+      boardState.archiveElement(id)
+      break
+
+    case 'element:duplicate': {
+      const { offsetX = 40, offsetY = 40 } = data
+      const duped = boardState.duplicateElement(id, offsetX, offsetY)
+      _createInstanceAndBroadcast(duped)
+      break
+    }
+
+    case 'element:update':
+      boardState.updateElement(id, data)
+      break
+
+    case 'link:create': {
+      const { fromElementId, fromPortKey, toElementId, toPortKey } = data
+      boardState.createLink({ fromElementId, fromPortKey, toElementId, toPortKey })
+      break
+    }
+
+    case 'link:delete':
+      boardState.removeLink(id)
+      break
+
+    case 'zone:create': {
+      const { x, y, width, height, name, color } = data
+      boardState.createZone({ x, y, width, height, name, color })
+      break
+    }
+
+    case 'zone:update':
+      boardState.updateZone(id, data)
+      break
+
+    case 'zone:delete':
+      boardState.removeZone(id)
+      break
+
+    case 'view:save': {
+      const { name, cameraX, cameraY, zoom } = data
+      boardState.createView({ name, cameraX, cameraY, zoom })
+      break
+    }
+
+    case 'view:delete':
+      boardState.removeView(id)
+      break
+
+    case 'meta:set': {
+      const { key, value } = data
+      boardState.setMeta(key, value)
+      break
+    }
+
+    case 'shape:add': {
+      const { subtype, x, y, width, height, fillColor, strokeColor, strokeWidth, text, title, textAlign } = data
+      boardState.createShape({ subtype, x, y, width, height, fillColor, strokeColor, strokeWidth, text, title, textAlign })
+      break
+    }
+
+    case 'shape:update':
+      boardState.updateShape(id, data)
+      break
+
+    case 'shape:delete':
+      boardState.removeShape(id)
+      break
+
+    default:
+      throw new Error(`Unknown board action type: ${type}`)
+  }
+}
+
+function _createInstanceAndBroadcast(el) {
+  try {
+    createInstance(el)
+    const viewData = getViewData(el.id)
+    const ports    = getPorts(el.id)
+    if (Object.keys(viewData).length > 0 || ports.length > 0) {
+      getIO().to('board').emit('board:delta', {
+        type: 'element:view',
+        id:   el.id,
+        viewData: { ...viewData, ports },
+      })
+    }
+  } catch (err) {
+    console.error('[socket] _createInstanceAndBroadcast error:', err.message)
+  }
+}
+
+module.exports = { registerSocketHandlers }