@newsails/veil-studio 1.0.0

package/server/utils/elements/text.js

@@ -0,0 +1,29 @@
+'use strict'
+
+module.exports = {
+  type:          'text',
+  name:          'Text',
+  description:   'A plain text note.',
+  icon:          'type',
+  defaultWidth:  200,
+  defaultHeight: 80,
+  expansionMode: 'inline',
+  tags:          ['data', 'content'],
+  isBuiltIn:     true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() { return { content: element.data.content || '' } },
+      getPorts() {
+        return [{ key: 'text-out', direction: 'output', dataType: 'text', label: 'Text Out' }]
+      },
+      actions: {
+        update({ content } = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, content } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/todo-list.js

@@ -0,0 +1,57 @@
+'use strict'
+
+module.exports = {
+  type:          'todo-list',
+  name:          'Todo List',
+  description:   'A simple todo list linked to an agent session.',
+  icon:          'check-square',
+  defaultWidth:  200,
+  defaultHeight: 120,
+  expansionMode: 'inline',
+  tags:          ['cli', 'todo'],
+  isBuiltIn:     true,
+
+  createInstance(context) {
+    const { element } = context
+
+    return {
+      getViewData() {
+        return {
+          sessionId: element.data.sessionId || null,
+          agentName: element.data.agentName || null,
+          items:     element.data.items || [],
+        }
+      },
+
+      getPorts() {
+        return [
+          { key: 'items-in',  direction: 'input',  dataType: 'any',  label: 'Items In' },
+          { key: 'items-out', direction: 'output', dataType: 'any',  label: 'Items Out' },
+        ]
+      },
+
+      actions: {
+        addItem({ text } = {}) {
+          if (!text) throw new Error('text required')
+          const { updateElement } = require('../board-state.js')
+          const items = [...(element.data.items || []), { id: Date.now().toString(), text, done: false }]
+          updateElement(element.id, { data: { ...element.data, items } })
+        },
+
+        toggleItem({ id } = {}) {
+          if (!id) throw new Error('id required')
+          const { updateElement } = require('../board-state.js')
+          const items = (element.data.items || []).map(i => i.id === id ? { ...i, done: !i.done } : i)
+          updateElement(element.id, { data: { ...element.data, items } })
+        },
+
+        removeItem({ id } = {}) {
+          if (!id) throw new Error('id required')
+          const { updateElement } = require('../board-state.js')
+          const items = (element.data.items || []).filter(i => i.id !== id)
+          updateElement(element.id, { data: { ...element.data, items } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/url-card.js

@@ -0,0 +1,37 @@
+'use strict'
+
+module.exports = {
+  type:          'url-card',
+  name:          'URL Card',
+  description:   'Display a URL with title, description, and favicon.',
+  icon:          'link',
+  defaultWidth:  260,
+  defaultHeight: 90,
+  expansionMode: 'inline',
+  tags:          ['data', 'web'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          url:         element.data.url || '',
+          title:       element.data.title || '',
+          description: element.data.description || '',
+          favicon:     element.data.favicon || null,
+        }
+      },
+      getPorts() {
+        return [{ key: 'url-out', direction: 'output', dataType: 'text', label: 'URL Out' }]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/web-search-query.js

@@ -0,0 +1,46 @@
+'use strict'
+
+module.exports = {
+  type:          'web-search-query',
+  name:          'Web Search Query',
+  description:   'A web search query to send to an agent or run directly.',
+  icon:          'search',
+  defaultWidth:  220,
+  defaultHeight: 80,
+  expansionMode: 'inline',
+  tags:          ['research', 'web'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          query:   element.data.query || '',
+          engine:  element.data.engine || null,
+          filters: element.data.filters || null,
+        }
+      },
+      getPorts() {
+        return [{ key: 'query-out', direction: 'output', dataType: 'text', label: 'Query Out' }]
+      },
+      actions: {
+        sendToAgent({ agentName } = {}) {
+          if (!agentName) throw new Error('agentName required')
+          const { createElement } = require('../board-state.js')
+          createElement({
+            type:   'task',
+            x:      element.x + 240,
+            y:      element.y,
+            data:   { agentName, prompt: element.data.query },
+          })
+        },
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

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

@@ -0,0 +1,37 @@
+'use strict'
+
+module.exports = {
+  type:          'web-snapshot',
+  name:          'Web Snapshot',
+  description:   'A captured snapshot of a web page.',
+  icon:          'globe',
+  defaultWidth:  240,
+  defaultHeight: 100,
+  expansionMode: 'popup',
+  tags:          ['data', 'web', 'research'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          url:        element.data.url || '',
+          title:      element.data.title || '',
+          content:    element.data.content || '',
+          capturedAt: element.data.capturedAt || null,
+        }
+      },
+      getPorts() {
+        return [{ key: 'text-out', direction: 'output', dataType: 'text', label: 'Content Out' }]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/file-utils.js

@@ -0,0 +1,88 @@
+'use strict'
+
+const path = require('path')
+const fs = require('fs')
+const { PROJECT_DIR } = require('./config.js')
+
+const EXCLUDED_NAMES = new Set(['node_modules', '.git', '.nuxt', '.output', '.cache'])
+const MAX_DEPTH = 6
+
+function _safePath(relativePath) {
+  const resolved = path.resolve(PROJECT_DIR, relativePath)
+  if (!resolved.startsWith(PROJECT_DIR)) {
+    const err = new Error(`Access denied: path outside PROJECT_DIR`)
+    err.status = 403
+    throw err
+  }
+  return resolved
+}
+
+function buildFileTree(dir = PROJECT_DIR, depth = 0) {
+  if (depth >= MAX_DEPTH) return []
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  const result = []
+  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 stat = fs.statSync(fullPath)
+      result.push({
+        name: entry.name,
+        path: relPath,
+        type: 'file',
+        size: stat.size,
+      })
+    }
+  }
+  return result
+}
+
+function readProjectFile(relativePath) {
+  const abs = _safePath(relativePath)
+  return fs.readFileSync(abs, 'utf8')
+}
+
+function writeProjectFile(relativePath, content) {
+  const abs = _safePath(relativePath)
+  fs.mkdirSync(path.dirname(abs), { recursive: true })
+  fs.writeFileSync(abs, content, 'utf8')
+}
+
+function createProjectDir(relativePath) {
+  const abs = _safePath(relativePath)
+  fs.mkdirSync(abs, { recursive: true })
+}
+
+function renameProjectFile(fromRel, toRel) {
+  const from = _safePath(fromRel)
+  const to   = _safePath(toRel)
+  fs.mkdirSync(path.dirname(to), { recursive: true })
+  fs.renameSync(from, to)
+}
+
+function deleteProjectPath(relativePath) {
+  const abs = _safePath(relativePath)
+  const stat = fs.statSync(abs)
+  if (stat.isDirectory()) {
+    fs.rmSync(abs, { recursive: true, force: true })
+  } else {
+    fs.unlinkSync(abs)
+  }
+}
+
+module.exports = {
+  buildFileTree,
+  readProjectFile,
+  writeProjectFile,
+  createProjectDir,
+  renameProjectFile,
+  deleteProjectPath,
+}

package/server/utils/session-watcher.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const { veilGet } = require('./veil-client.js')
+const { getIO } = require('./socket-io.js')
+
+// Map<sessionId, number> — message count baseline (messages already seen by Studio)
+// undefined = not initialized → first syncSession will set baseline without emitting
+const _sessionState = new Map()
+
+// Prevent concurrent syncs for the same session
+const _syncing = new Set()
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+async function syncSession(sessionId) {
+  if (_syncing.has(sessionId)) return
+  _syncing.add(sessionId)
+  try {
+    await _doSync(sessionId)
+  } catch (err) {
+    console.warn(`[session-sync] syncSession ${sessionId} failed: ${err.message}`)
+  } finally {
+    _syncing.delete(sessionId)
+  }
+}
+
+async function touchSession(sessionId) {
+  // Refresh baseline without emitting — call after chat:send completes
+  // so the Studio-sent messages are not re-emitted on the next external sync
+  try {
+    const res = await veilGet(`/sessions/${encodeURIComponent(sessionId)}/messages`)
+    const messages = Array.isArray(res) ? res : (res.messages ?? [])
+    _sessionState.set(sessionId, messages.length)
+  } catch { /* best-effort, ignore errors */ }
+}
+
+async function initSessionStates() {
+  // Pre-populate message-count baselines for all active sessions so that
+  // the first syncSession call only emits truly NEW messages
+  try {
+    const res = await veilGet('/sessions')
+    const sessions = Array.isArray(res) ? res : (res.sessions ?? [])
+    const active = sessions.filter(s => s.status !== 'closed' && s.status !== 'deleted')
+
+    await Promise.all(active.map(async (s) => {
+      const id = s.id || s.sessionId
+      if (!id || _sessionState.has(id)) return
+      try {
+        const msgRes = await veilGet(`/sessions/${encodeURIComponent(id)}/messages`)
+        const msgs = Array.isArray(msgRes) ? msgRes : (msgRes.messages ?? [])
+        _sessionState.set(id, msgs.length)
+      } catch {
+        _sessionState.set(id, 0)
+      }
+    }))
+
+    if (active.length > 0)
+      console.log(`[session-sync] Baselines initialized for ${active.length} session(s)`)
+  } catch (err) {
+    console.warn(`[session-sync] initSessionStates failed: ${err.message}`)
+  }
+}
+
+// ─── Internal ────────────────────────────────────────────────────────────────
+
+async function _doSync(sessionId) {
+  const res = await veilGet(`/sessions/${encodeURIComponent(sessionId)}/messages`)
+  const messages = Array.isArray(res) ? res : (res.messages ?? [])
+
+  const baseline = _sessionState.get(sessionId)
+
+  if (baseline === undefined) {
+    // First contact with this session — set baseline without emitting historical messages
+    _sessionState.set(sessionId, messages.length)
+    return
+  }
+
+  const newMessages = messages.slice(baseline)
+  _sessionState.set(sessionId, messages.length)
+
+  if (newMessages.length === 0) return
+
+  const io = getIO()
+
+  for (const msg of newMessages) {
+    if (msg.role === 'user') {
+      const content = typeof msg.content === 'string'
+        ? msg.content
+        : (msg.content?.[0]?.text ?? '')
+      io.to('board').emit('chat:user-message', {
+        sessionId,
+        agentName: msg.agentName || '',
+        message: content,
+      })
+    } else if (msg.role === 'assistant') {
+      io.to('board').emit('chat:stream', {
+        sessionId,
+        eventType: 'message',
+        data: msg,
+      })
+    }
+  }
+
+  // Signal end of streaming after the batch
+  io.to('board').emit('chat:done', { sessionId, message: null, tokenUsage: null })
+}
+
+module.exports = { syncSession, touchSession, initSessionStates }

package/server/utils/socket-io.js

@@ -0,0 +1,14 @@
+'use strict'
+
+let _io = null
+
+function getIO() {
+  if (!_io) throw new Error('Socket.IO not initialized yet — call setIO(io) first')
+  return _io
+}
+
+function setIO(io) {
+  _io = io
+}
+
+module.exports = { getIO, setIO }

package/server/utils/veil-client.js

@@ -0,0 +1,185 @@
+'use strict'
+
+const { VEIL_API, VEIL_SECRET } = require('./config.js')
+
+function _headers(extra = {}) {
+  const h = { 'Content-Type': 'application/json', ...extra }
+  if (VEIL_SECRET) h['X-Veil-Secret'] = VEIL_SECRET
+  return h
+}
+
+async function _checkResponse(res) {
+  if (res.ok) return res
+  let msg = `VeilCLI error ${res.status}`
+  try {
+    const body = await res.json()
+    if (body && body.error) {
+      msg = body.error.message || body.error.code || msg
+    }
+  } catch (_) {}
+  throw new Error(msg)
+}
+
+async function veilGet(apiPath, query = {}) {
+  const url = new URL(`${VEIL_API}${apiPath}`)
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== undefined && v !== null) url.searchParams.set(k, v)
+  }
+  const res = await fetch(url.toString(), { headers: _headers() })
+  await _checkResponse(res)
+  return res.json()
+}
+
+async function veilPost(apiPath, body = {}) {
+  const res = await fetch(`${VEIL_API}${apiPath}`, {
+    method: 'POST',
+    headers: _headers(),
+    body: JSON.stringify(body),
+  })
+  await _checkResponse(res)
+  return res.json()
+}
+
+async function veilPut(apiPath, body = {}) {
+  const res = await fetch(`${VEIL_API}${apiPath}`, {
+    method: 'PUT',
+    headers: _headers(),
+    body: JSON.stringify(body),
+  })
+  await _checkResponse(res)
+  return res.json()
+}
+
+async function veilDelete(apiPath, query = {}) {
+  const url = new URL(`${VEIL_API}${apiPath}`)
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== undefined && v !== null) url.searchParams.set(k, v)
+  }
+  const res = await fetch(url.toString(), {
+    method: 'DELETE',
+    headers: _headers(),
+  })
+  await _checkResponse(res)
+  return res.json()
+}
+
+async function* veilStreamChat(agentName, message, sessionId) {
+  const body = { message, sse: true }
+  if (sessionId) body.sessionId = sessionId
+
+  const res = await fetch(`${VEIL_API}/agents/${encodeURIComponent(agentName)}/chat`, {
+    method: 'POST',
+    headers: _headers(),
+    body: JSON.stringify(body),
+  })
+  await _checkResponse(res)
+
+  const reader = res.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    buffer += decoder.decode(value, { stream: true })
+
+    const parts = buffer.split('\n\n')
+    buffer = parts.pop()
+
+    for (const part of parts) {
+      const lines = part.trim().split('\n')
+      let eventType = null
+      let dataLine = null
+      for (const line of lines) {
+        if (line.startsWith('event:')) eventType = line.slice(6).trim()
+        if (line.startsWith('data:'))  dataLine  = line.slice(5).trim()
+      }
+      if (!dataLine) continue
+      try {
+        const data = JSON.parse(dataLine)
+        yield { eventType: eventType || 'message', data }
+      } catch (_) {}
+    }
+  }
+}
+
+async function* veilStreamSessionEvents(sessionId, signal) {
+  const res = await fetch(`${VEIL_API}/sessions/${encodeURIComponent(sessionId)}/events`, {
+    headers: _headers({ Accept: 'text/event-stream' }),
+    signal,
+  })
+  await _checkResponse(res)
+
+  const reader = res.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    buffer += decoder.decode(value, { stream: true })
+
+    const parts = buffer.split('\n\n')
+    buffer = parts.pop()
+
+    for (const part of parts) {
+      const lines = part.trim().split('\n')
+      let eventType = null
+      let dataLine = null
+      for (const line of lines) {
+        if (line.startsWith('event:')) eventType = line.slice(6).trim()
+        if (line.startsWith('data:'))  dataLine  = line.slice(5).trim()
+      }
+      if (!dataLine) continue
+      try {
+        const data = JSON.parse(dataLine)
+        yield { eventType: eventType || 'message', data }
+      } catch (_) {}
+    }
+  }
+}
+
+async function* veilStreamTaskEvents(taskId) {
+  const res = await fetch(`${VEIL_API}/tasks/${encodeURIComponent(taskId)}/events`, {
+    headers: _headers({ Accept: 'text/event-stream' }),
+  })
+  await _checkResponse(res)
+
+  const reader = res.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    buffer += decoder.decode(value, { stream: true })
+
+    const parts = buffer.split('\n\n')
+    buffer = parts.pop()
+
+    for (const part of parts) {
+      const lines = part.trim().split('\n')
+      let eventType = null
+      let dataLine = null
+      for (const line of lines) {
+        if (line.startsWith('event:')) eventType = line.slice(6).trim()
+        if (line.startsWith('data:'))  dataLine  = line.slice(5).trim()
+      }
+      if (!dataLine) continue
+      try {
+        const data = JSON.parse(dataLine)
+        yield { eventType: eventType || 'task.event', data }
+      } catch (_) {}
+    }
+  }
+}
+
+module.exports = {
+  veilGet,
+  veilPost,
+  veilPut,
+  veilDelete,
+  veilStreamChat,
+  veilStreamSessionEvents,
+  veilStreamTaskEvents,
+}