@newsails/veil-studio 1.0.0 → 2.0.0

package/server/utils/veil-client.js

@@ -10,14 +10,16 @@ function _headers(extra = {}) {
 
 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)
+  let body = null
+  try { body = await res.json() } catch (_) {}
+  const e = body?.error || {}
+  const err = new Error(e.message || `VeilCLI error ${res.status}`)
+  err.name    = 'VeilError'
+  err.code    = e.code    || `HTTP_${res.status}`
+  err.details = e.details
+  err.phase   = e.phase
+  err.status  = res.status
+  throw err
 }
 
 async function veilGet(apiPath, query = {}) {
@@ -50,6 +52,16 @@ async function veilPut(apiPath, body = {}) {
   return res.json()
 }
 
+async function veilPatch(apiPath, body = {}) {
+  const res = await fetch(`${VEIL_API}${apiPath}`, {
+    method: 'PATCH',
+    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)) {
@@ -63,13 +75,26 @@ async function veilDelete(apiPath, query = {}) {
   return res.json()
 }
 
-async function* veilStreamChat(agentName, message, sessionId) {
+async function* veilStreamChat(agentName, message, sessionId, { signal, attachments, continueResume } = {}) {
   const body = { message, sse: true }
   if (sessionId) body.sessionId = sessionId
+  // Veil allows empty message when paired with `continue: true` — used by
+  // the cog menu's "Continue" item to ask the agent to keep generating from
+  // where it left off without a new user message.
+  if (continueResume) body.continue = true
+  // PR-3 item 2: forward outbound structured attachments to Veil's
+  // `POST /agents/:name/chat` body — accepted shape is
+  // `[{ kind, url, mime_type?, name? }]` per audit-chat-sessions.md §A. We do
+  // NOT validate or transform here; Veil's per-attachment validator is
+  // authoritative (8MB cap, audio data-only, claude-cli rejection via
+  // MODEL_MODALITY_UNSUPPORTED). PR-1 item 7 preserves the structured error
+  // envelope back to the client.
+  if (Array.isArray(attachments) && attachments.length) body.attachments = attachments
 
   const res = await fetch(`${VEIL_API}/agents/${encodeURIComponent(agentName)}/chat`, {
     method: 'POST',
     headers: _headers(),
+    signal: signal || null,
     body: JSON.stringify(body),
   })
   await _checkResponse(res)
@@ -103,6 +128,196 @@ async function* veilStreamChat(agentName, message, sessionId) {
   }
 }
 
+const TERMINAL_AI_SYSTEM_PROMPT =
+  'You are a shell command generator. ' +
+  'Return ONLY the raw shell command the user should run — ' +
+  'no explanation, no markdown, no backticks, no preamble. ' +
+  'If the task requires multiple commands, join them with && or ; on a single line unless a script is truly needed.'
+
+/**
+ * One-shot AI completion for terminal command generation.
+ * Hits the OpenAI-compatible /v1/chat/completions endpoint directly,
+ * bypassing agents so there is no session history or agent-level system prompt.
+ *
+ * @param {string} prompt - User's natural-language description
+ * @param {{ model: string, cwd?: string, signal?: AbortSignal }} opts
+ */
+async function* veilStreamTerminalAi(prompt, { model, cwd, signal } = {}) {
+  const messages = [
+    { role: 'system', content: TERMINAL_AI_SYSTEM_PROMPT + (cwd ? `\nCurrent directory: ${cwd}` : '') },
+    { role: 'user',   content: prompt },
+  ]
+
+  const body = { messages, sse: true, max_tokens: 512 }
+  if (model) body.model = model
+
+  const res = await fetch(`${VEIL_API}/completions`, {
+    method:  'POST',
+    headers: _headers(),
+    signal:  signal || null,
+    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)
+        if (eventType === 'chunk' && data.content) yield data.content
+        if (eventType === 'done')  return
+        if (eventType === 'error') throw new Error(data.error || 'AI error')
+      } catch (err) {
+        if (err.message !== 'AI error' && !(err instanceof SyntaxError)) throw err
+        if (eventType === 'error') throw err
+      }
+    }
+  }
+}
+
+const GIT_COMMIT_AI_SYSTEM_PROMPT =
+  'You are a git commit message generator. ' +
+  'Given a staged diff, write a concise commit message in the imperative mood. ' +
+  'Return ONLY the commit message — no explanation, no markdown, no quotes, no preamble. ' +
+  'The first line must be a short summary under 72 characters. ' +
+  'If the changes warrant it, add a blank line followed by a brief body (2-4 lines max).'
+
+/**
+ * Streams an AI-generated git commit message based on the staged diff.
+ * Hits /v1/chat/completions directly — no session history.
+ *
+ * @param {string} diff - Output of `git diff --cached`
+ * @param {Array<{shortHash:string,subject:string,author:string}>} recentCommits - last N commits for style reference
+ * @param {{ model: string, signal?: AbortSignal }} opts
+ */
+async function* veilStreamGitCommitAi(diff, recentCommits, { model, diffSource = 'staged', signal } = {}) {
+  let userContent = ''
+
+  if (recentCommits?.length) {
+    const log = recentCommits.map(c => `  ${c.shortHash}  ${c.subject}  (${c.author})`).join('\n')
+    userContent += `Recent commit history (use as style reference only):\n${log}\n\n`
+  }
+
+  if (diff?.trim()) {
+    const label = diffSource === 'working-tree' ? 'Working tree diff (unstaged changes)' : 'Staged diff'
+    userContent += `${label} to summarize into a commit message:\n\n${diff.slice(0, 6000)}`
+  } else {
+    userContent += 'No diff is available — generate a short placeholder commit message.'
+  }
+
+  const messages = [
+    { role: 'system', content: GIT_COMMIT_AI_SYSTEM_PROMPT },
+    { role: 'user',   content: userContent },
+  ]
+
+  console.log('Git AI commit msg generation', messages)
+
+  const body = { messages, sse: true, max_tokens: 256 }
+  if (model) body.model = model
+
+  const res = await fetch(`${VEIL_API}/completions`, {
+    method:  'POST',
+    headers: _headers(),
+    signal:  signal || null,
+    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)
+        if (eventType === 'chunk' && data.content) yield data.content
+        if (eventType === 'done')  return
+        if (eventType === 'error') throw new Error(data.error || 'AI error')
+      } catch (err) {
+        if (err.message !== 'AI error' && !(err instanceof SyntaxError)) throw err
+        if (eventType === 'error') throw err
+      }
+    }
+  }
+}
+
+/**
+ * Cancel an in-flight Veil session generation upstream.
+ *
+ * Idempotent: 404 is treated as success (session already gone / never started).
+ * Any other error is logged at warn-level and swallowed — the caller is
+ * fire-and-forget; rejecting would surface noise in the chat:stop UX path.
+ *
+ * Used by `chat:stop` (real interrupt) and by `chat:send` when starting a new
+ * stream while one is already active for the same sessionId (race-free
+ * single-stream-per-session invariant).
+ */
+async function veilCancelSession(sessionId) {
+  try {
+    await veilPost(`/sessions/${encodeURIComponent(sessionId)}/cancel`)
+  } catch (err) {
+    if (err && err.status === 404) return
+    console.warn(`[veilCancelSession] ${sessionId}:`, err && err.message)
+  }
+}
+
+/**
+ * PR-1 item 2A: best-effort fetch of Veil's authoritative active-streams list.
+ *
+ * GET /sessions/streaming returns either a bare array of
+ *   `{ sessionId, agentName, startedAt }` records or a wrapper object
+ *   `{ streaming: [...] }` (the latter is the legacy shape — see
+ *   `api/routes/sessions.js`). Both are tolerated.
+ *
+ * NEVER throws — restoration is best-effort. A single failed fetch on Studio
+ * reconnect must NOT wedge the connection handler. Returns `[]` on any error.
+ */
+async function veilGetStreaming() {
+  try {
+    const json = await veilGet('/sessions/streaming')
+    if (Array.isArray(json)) return json
+    if (json && Array.isArray(json.streaming)) return json.streaming
+    return []
+  } catch (err) {
+    console.warn('[veilGetStreaming]', err && err.message)
+    return []
+  }
+}
+
 async function* veilStreamSessionEvents(sessionId, signal) {
   const res = await fetch(`${VEIL_API}/sessions/${encodeURIComponent(sessionId)}/events`, {
     headers: _headers({ Accept: 'text/event-stream' }),
@@ -178,8 +393,13 @@ module.exports = {
   veilGet,
   veilPost,
   veilPut,
+  veilPatch,
   veilDelete,
   veilStreamChat,
+  veilStreamTerminalAi,
+  veilStreamGitCommitAi,
   veilStreamSessionEvents,
   veilStreamTaskEvents,
+  veilCancelSession,
+  veilGetStreaming,
 }

package/server/utils/veil-ws.js

@@ -5,6 +5,8 @@ const { VEIL_WS_URL, VEIL_SECRET } = require('./config.js')
 const { getIO } = require('./socket-io.js')
 const boardState = require('./board-state.js')
 const { initSessionStates } = require('./session-watcher.js')
+const { orchestrationGraph, initOrchestrationGraph } = require('./orchestration-graph.js')
+const { veilGet } = require('./veil-client.js')
 
 let _activeStreams = null
 let _setElementStreamingFn = null
@@ -51,6 +53,8 @@ function connectVeilWS() {
       getIO().emit('veil:status', { connected: true })
     } catch (_) {}
     initSessionStates().catch(e => console.warn('[veil-ws] initSessionStates:', e.message))
+    orchestrationGraph.setIO(getIO())
+    initOrchestrationGraph(veilGet).catch(e => console.warn('[veil-ws] initOrchestrationGraph:', e.message))
   })
 
   _ws.on('message', (data) => {
@@ -92,6 +96,15 @@ function _isExternalSession(sessionId) {
 function _handleVeilEvent(event) {
   if (!event || !event.type) return
 
+  // PR-8 item 2: opt-in event-type tracer for sub-session UX investigation.
+  // Enabled only when STUDIO_DEBUG_WS=1 — zero cost in production. Surfaces
+  // the event ordering across `chat.event/iteration.start`, `session.stream`
+  // (sse=true path), and `chat.message` (sse=false path emitted by the
+  // `agent_message` tool). Per critique Med3, plain console.log (not dbg).
+  if (process.env.STUDIO_DEBUG_WS === '1') {
+    console.log(`[veil-ws] event ${event.type} sid=${event.sessionId || '-'}`)
+  }
+
   const io = getIO()
 
   // ── session.stream — mirrors SSE stream for every session in real-time ──────
@@ -113,6 +126,11 @@ function _handleVeilEvent(event) {
     } else {
       // inference.chunk, inference.tool, message (assistant/tool)
       try { io.to('board').emit('chat:stream', { sessionId, eventType, data }) } catch (_) {}
+      // Feed orchestration graph from external session streams
+      if (eventType === 'message' && data) {
+        const oDeltas = orchestrationGraph.processMessage(sessionId, data, '')
+        if (oDeltas) orchestrationGraph._emitDeltas(oDeltas)
+      }
     }
     return
   }
@@ -170,6 +188,54 @@ function _handleVeilEvent(event) {
     return
   }
 
+  // ── session.created — Veil announces a new sub-session ─────────────────
+  // PR-9 (Miss1 / M4 critique): Veil's `core/router.js:416` emits
+  // `{ type: 'session.created', sessionId, agentName,
+  //    event: { mode, parentSessionId, instanceName, timestamp } }` whenever
+  // a sub-session is spawned (agent_spawn / agent_message). Studio previously
+  // dropped this event so freshly-spawned nodes had no `instance_name` /
+  // `parent_session_id` until the next /sessions rebuild on reconnect. We
+  // now live-stamp the orchestration graph so the popup shows accurate data
+  // immediately. handleSessionCreated emits its own deltas via the io ref
+  // configured at `setIO` time, so no broadcast is needed here.
+  if (event.type === 'session.created' && event.sessionId) {
+    const evt = event.event || {}
+    try {
+      orchestrationGraph.handleSessionCreated({
+        sessionId:         event.sessionId,
+        agentName:         event.agentName || '',
+        instance_name:     evt.instanceName ?? null,
+        parent_session_id: evt.parentSessionId ?? null,
+      })
+    } catch (err) {
+      console.warn('[veil-ws] session.created handler:', err.message)
+    }
+    return
+  }
+
+  // ── session.budget_exceeded — bridge to chat:budget-exceeded for the client ──
+  // Per audit-controls-events.md:83-86, Veil emits
+  // `{ type:'session.budget_exceeded', sessionId, agentName, event:{ budgetType,
+  // limit, actual, timestamp } }` over the WS bus. Studio translates this into
+  // a dedicated `chat:budget-exceeded` Socket.IO event so `useSocket.ts` can
+  // subscribe without over-listening on the generic `veil:event` channel.
+  // The banner state lands in `chatStore.sessions[sid].budgetExceeded` and
+  // renders `<ChatBudgetBanner>` at the top of the chat panel until the user
+  // dismisses it.
+  if (event.type === 'session.budget_exceeded' && event.sessionId) {
+    try {
+      io.to('board').emit('chat:budget-exceeded', {
+        sessionId:  event.sessionId,
+        agentName:  event.agentName,
+        budgetType: event.event?.budgetType ?? 'max_tokens',
+        limit:      event.event?.limit ?? null,
+        actual:     event.event?.actual ?? null,
+        timestamp:  event.event?.timestamp,
+      })
+    } catch (_) {}
+    return
+  }
+
   // ── chat.response — fallback: stop streaming if session.stream done never fired ─
   if (event.type === 'chat.response' && event.sessionId) {
     const sessionId = event.sessionId

package/nuxt-app/.output/public/_nuxt/builds/latest.json

@@ -1 +0,0 @@
-{"id":"6b28df26-54af-4fad-a1f0-38808960d9fe","timestamp":1773909250273}

package/nuxt-app/.output/public/_nuxt/builds/meta/6b28df26-54af-4fad-a1f0-38808960d9fe.json

@@ -1 +0,0 @@
-{"id":"6b28df26-54af-4fad-a1f0-38808960d9fe","timestamp":1773909250273,"matcher":{"static":{},"wildcard":{},"dynamic":{}},"prerendered":[]}