@newsails/veil-studio 1.0.0 → 2.0.0

package/server/routes/ai.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const express = require('express')
+const { VEIL_API, VEIL_SECRET } = require('../utils/config.js')
+
+const router = express.Router()
+
+// Generic completions proxy — used by Monaco inline AI and any future AI features
+// that need a direct request/response (non-streaming) completion.
+router.post('/inline', async (req, res) => {
+  const { model, messages } = req.body ?? {}
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return res.status(400).json({ error: 'messages array is required' })
+  }
+
+  const body    = { model, messages, max_tokens: 8192 }
+  const headers = { 'Content-Type': 'application/json' }
+  if (VEIL_SECRET) headers['X-Veil-Secret'] = VEIL_SECRET
+
+  try {
+    const upstream = await fetch(`${VEIL_API}/completions`, {
+      method: 'POST',
+      headers,
+      body:   JSON.stringify(body),
+    })
+
+    if (!upstream.ok) {
+      const errText = await upstream.text()
+      return res.status(502).json({ error: errText })
+    }
+
+    const data    = await upstream.json()
+    const content = data?.message?.content ?? data?.choices?.[0]?.message?.content ?? ''
+    res.json({ content })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/files.js

@@ -1,15 +1,33 @@
 'use strict'
 
 const router = require('express').Router()
+const multer = require('multer')
+const fs = require('fs')
+const path = require('path')
+const { spawn } = require('child_process')
 const {
   buildFileTree,
+  getGitStatus,
+  getProjectFilePath,
   readProjectFile,
   writeProjectFile,
+  writeProjectFileBuffer,
   createProjectDir,
   renameProjectFile,
   deleteProjectPath,
+  acquireLock,
 } = require('../utils/file-utils.js')
 
+const { getIO } = require('../utils/socket-io.js')
+const { suppressPath } = require('../utils/file-watcher.js')
+
+const _upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 200 * 1024 * 1024 } })
+
+function _notifyChange(type, filePath) {
+  suppressPath(filePath)
+  try { getIO().emit('files:changed', { type, path: filePath }) } catch (_) {}
+}
+
 function handleError(res, err) {
   const status = err.status || 500
   res.status(status).json({ error: err.message })
@@ -33,12 +51,18 @@ router.get('/content', (req, res) => {
   }
 })
 
-router.put('/content', (req, res) => {
+router.put('/content', async (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 })
+    const release = await acquireLock(filePath)
+    try {
+      writeProjectFile(filePath, content ?? '')
+      _notifyChange('change', filePath)
+      res.json({ ok: true })
+    } finally {
+      release()
+    }
   } catch (err) {
     handleError(res, err)
   }
@@ -49,6 +73,7 @@ router.post('/mkdir', (req, res) => {
     const { path: dirPath } = req.body
     if (!dirPath) return res.status(400).json({ error: 'path required' })
     createProjectDir(dirPath)
+    _notifyChange('addDir', dirPath)
     res.json({ ok: true })
   } catch (err) {
     handleError(res, err)
@@ -60,6 +85,8 @@ router.post('/rename', (req, res) => {
     const { from, to } = req.body
     if (!from || !to) return res.status(400).json({ error: 'from and to required' })
     renameProjectFile(from, to)
+    _notifyChange('unlink', from)
+    _notifyChange('add', to)
     res.json({ ok: true })
   } catch (err) {
     handleError(res, err)
@@ -71,10 +98,99 @@ router.post('/delete', (req, res) => {
     const { path: targetPath } = req.body
     if (!targetPath) return res.status(400).json({ error: 'path required' })
     deleteProjectPath(targetPath)
+    _notifyChange('unlink', targetPath)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+router.post('/reveal', (req, res) => {
+  try {
+    const { path: targetPath } = req.body
+    if (!targetPath) return res.status(400).json({ error: 'path required' })
+    const abs = getProjectFilePath(targetPath)
+    const stat = fs.statSync(abs)
+    const toOpen = stat.isDirectory() ? abs : path.dirname(abs)
+    try {
+      const child = spawn('xdg-open', [toOpen], { detached: true, stdio: 'ignore' })
+      child.on('error', (e) => {
+        console.warn('[files:reveal] xdg-open failed:', e && e.message ? e.message : e)
+      })
+      child.unref()
+    } catch (spawnErr) {
+      return res.status(501).json({ error: 'xdg-open unavailable on this host' })
+    }
     res.json({ ok: true })
   } catch (err) {
     handleError(res, err)
   }
 })
 
+// GET /git-status — { relativePath: 'U'|'M'|'D'|'R' } or {} if not a git repo
+router.get('/git-status', (req, res) => {
+  try {
+    res.json(getGitStatus() ?? {})
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /download?path=... — streams the raw file (binary-safe, for images/downloads)
+router.get('/download', (req, res) => {
+  try {
+    const { path: filePath } = req.query
+    if (!filePath) return res.status(400).json({ error: 'path query param required' })
+    const absPath = getProjectFilePath(filePath)
+    res.download(absPath)
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET/HEAD /serve/* — path-style static-file route. Serves the raw bytes of a
+// project file with Express-derived Content-Type (so an iframe can render it
+// inline). Path-style is intentional: relative URLs inside a rendered HTML
+// (`<img src="./image.png">`) resolve against the iframe URL's directory, so
+// `/api/files/serve/<dir>/index.html` makes `./image.png` →
+// `/api/files/serve/<dir>/image.png`, which this same route serves. Query-param
+// style would break those.
+function _serveProjectFile(req, res) {
+  try {
+    // Express auto-decodes wildcard params; no manual decodeURIComponent needed.
+    const relPath = req.params[0] || ''
+    if (!relPath) return res.status(400).end()
+    const absPath = getProjectFilePath(relPath)
+    res.sendFile(absPath, (err) => {
+      if (!err) return
+      if (err.code === 'ENOENT')        return res.status(404).end()
+      if (err.status)                    return res.status(err.status).end()
+      res.status(500).end()
+    })
+  } catch (err) {
+    handleError(res, err)
+  }
+}
+// Express 4 routes HEAD requests to the matching GET handler automatically,
+// so the existence-probe (`fetch(..., { method: 'HEAD' })`) reaches this
+// without an explicit head() registration.
+router.get('/serve/*', _serveProjectFile)
+
+// POST /upload — multipart upload of browser files into the project filesystem
+router.post('/upload', _upload.array('files'), (req, res) => {
+  try {
+    const destPath = (req.body.destPath ?? '').replace(/^\/+|\/+$/g, '')
+    const uploaded = []
+    for (const file of (req.files ?? [])) {
+      const relPath = destPath ? `${destPath}/${file.originalname}` : file.originalname
+      writeProjectFileBuffer(relPath, file.buffer)
+      _notifyChange('add', relPath)
+      uploaded.push({ path: relPath, size: file.size })
+    }
+    res.json({ uploaded })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
 module.exports = router

package/server/routes/git.js

@@ -0,0 +1,276 @@
+'use strict'
+
+const router = require('express').Router()
+const git = require('../utils/git.js')
+
+function handleError(res, err) {
+  const status = err.status || 500
+  res.status(status).json({ error: err.message || String(err) })
+}
+
+// GET /api/git/status
+router.get('/status', (req, res) => {
+  try {
+    const status = git.getFullStatus()
+    if (!status) return res.json({ notARepo: true })
+    res.json(status)
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/diff?path=&staged=
+router.get('/diff', (req, res) => {
+  try {
+    const { path: filePath, staged } = req.query
+    if (!filePath) return res.status(400).json({ error: 'path required' })
+    const diff = git.getDiff(filePath, staged === 'true' || staged === '1')
+    res.json({ diff })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/file-head?path=
+router.get('/file-head', (req, res) => {
+  try {
+    const { path: filePath } = req.query
+    if (!filePath) return res.status(400).json({ error: 'path required' })
+    res.json({ content: git.getFileAtHead(filePath) })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/file-index?path=
+router.get('/file-index', (req, res) => {
+  try {
+    const { path: filePath } = req.query
+    if (!filePath) return res.status(400).json({ error: 'path required' })
+    res.json({ content: git.getFileAtIndex(filePath) })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/stage  { files: string[] }
+router.post('/stage', (req, res) => {
+  try {
+    const { files } = req.body
+    if (!Array.isArray(files) || !files.length) return res.status(400).json({ error: 'files array required' })
+    git.stageFiles(files)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/unstage  { files: string[] }
+router.post('/unstage', (req, res) => {
+  try {
+    const { files } = req.body
+    if (!Array.isArray(files) || !files.length) return res.status(400).json({ error: 'files array required' })
+    git.unstageFiles(files)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/discard  { files: string[] }
+router.post('/discard', (req, res) => {
+  try {
+    const { files } = req.body
+    if (!Array.isArray(files) || !files.length) return res.status(400).json({ error: 'files array required' })
+    git.discardChanges(files)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/commit  { message, amend? }
+router.post('/commit', (req, res) => {
+  try {
+    const { message, amend } = req.body
+    const result = git.commit(message, !!amend)
+    res.json({ ok: true, ...result })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/commit-stat?hash=
+router.get('/commit-stat', (req, res) => {
+  try {
+    const { hash } = req.query
+    if (!hash) return res.status(400).json({ error: 'hash required' })
+    res.json(git.getCommitStat(hash))
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/commit-files?hash=
+router.get('/commit-files', (req, res) => {
+  try {
+    const { hash } = req.query
+    if (!hash) return res.status(400).json({ error: 'hash required' })
+    res.json(git.getCommitFiles(hash))
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/file-at-commit?hash=&path=
+router.get('/file-at-commit', (req, res) => {
+  try {
+    const { hash, path: filePath } = req.query
+    if (!hash || !filePath) return res.status(400).json({ error: 'hash and path required' })
+    res.json({ content: git.getFileAtCommit(hash, filePath) })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/log?limit=
+router.get('/log', (req, res) => {
+  try {
+    const limit = parseInt(req.query.limit, 10) || 50
+    res.json(git.getLog(limit))
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/branches
+router.get('/branches', (req, res) => {
+  try {
+    res.json(git.getBranches())
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/checkout  { branch }
+router.post('/checkout', (req, res) => {
+  try {
+    const { branch } = req.body
+    if (!branch) return res.status(400).json({ error: 'branch required' })
+    git.checkoutBranch(branch)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/branch/create  { name, from? }
+router.post('/branch/create', (req, res) => {
+  try {
+    const { name, from } = req.body
+    if (!name) return res.status(400).json({ error: 'name required' })
+    git.createBranch(name, from || null)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/branch/delete  { name, force? }
+router.post('/branch/delete', (req, res) => {
+  try {
+    const { name, force } = req.body
+    if (!name) return res.status(400).json({ error: 'name required' })
+    git.deleteBranch(name, !!force)
+    res.json({ ok: true })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/remotes
+router.get('/remotes', (req, res) => {
+  try {
+    res.json(git.getRemotes())
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/pull  { remote?, branch? }
+router.post('/pull', (req, res) => {
+  try {
+    const { remote, branch } = req.body ?? {}
+    const output = git.pull(remote || null, branch || null)
+    res.json({ ok: true, output })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/push  { remote?, branch?, force? }
+router.post('/push', (req, res) => {
+  try {
+    const { remote, branch, force } = req.body ?? {}
+    const output = git.push(remote || null, branch || null, !!force)
+    res.json({ ok: true, output })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/fetch  { remote? }
+router.post('/fetch', (req, res) => {
+  try {
+    const { remote } = req.body ?? {}
+    const output = git.fetchRemote(remote || null)
+    res.json({ ok: true, output })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// GET /api/git/stash/list
+router.get('/stash/list', (req, res) => {
+  try {
+    res.json(git.getStashList())
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/stash/push  { message?, includeUntracked? }
+router.post('/stash/push', (req, res) => {
+  try {
+    const { message, includeUntracked } = req.body ?? {}
+    const output = git.stashPush(message || null, !!includeUntracked)
+    res.json({ ok: true, output })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/stash/pop  { index? }
+router.post('/stash/pop', (req, res) => {
+  try {
+    const { index } = req.body ?? {}
+    const output = git.stashPop(index ?? 0)
+    res.json({ ok: true, output })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+// POST /api/git/stash/drop  { index }
+router.post('/stash/drop', (req, res) => {
+  try {
+    const { index } = req.body ?? {}
+    if (index === undefined || index === null) return res.status(400).json({ error: 'index required' })
+    const output = git.stashDrop(index)
+    res.json({ ok: true, output })
+  } catch (err) {
+    handleError(res, err)
+  }
+})
+
+module.exports = router

package/server/routes/stt.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const express = require('express')
+const multer  = require('multer')
+const { VEIL_API, VEIL_SECRET } = require('../utils/config.js')
+
+const router = express.Router()
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits:  { fileSize: 25 * 1024 * 1024 }, // 25 MB
+})
+
+router.post('/transcribe', upload.single('audio'), async (req, res) => {
+  if (!req.file) return res.status(400).json({ error: 'No audio file provided' })
+
+  const model    = req.body.model || 'google/gemini-2.5-flash-lite'
+  const audioB64 = req.file.buffer.toString('base64')
+  const fmt      = (req.file.mimetype || 'audio/webm').split('/')[1]?.split(';')[0] || 'webm'
+
+  const body = {
+    model,
+    messages: [{
+      role:    'user',
+      content: [
+        {
+          type:        'input_audio',
+          input_audio: { data: audioB64, format: fmt },
+        },
+        {
+          type: 'text',
+          text: 'Transcribe this audio exactly as spoken. Return only the transcribed text, nothing else.',
+        },
+      ],
+    }],
+    max_tokens: 2048,
+  }
+
+  // Debug snapshot — audio data replaced with a readable summary
+  const debugPrompt = JSON.parse(JSON.stringify(body))
+  debugPrompt.messages[0].content[0].input_audio.data = `[base64 audio, ${req.file.buffer.length} bytes, format: ${fmt}]`
+
+  const headers = { 'Content-Type': 'application/json' }
+  if (VEIL_SECRET) headers['X-Veil-Secret'] = VEIL_SECRET
+
+  try {
+    const upstream = await fetch(`${VEIL_API}/completions`, {
+      method: 'POST',
+      headers,
+      body:   JSON.stringify(body),
+    })
+
+    if (!upstream.ok) {
+      const errText = await upstream.text()
+      return res.status(502).json({ error: errText })
+    }
+
+    const data = await upstream.json()
+    let text = data?.message?.content ?? data?.choices?.[0]?.message?.content ?? ''
+    if (text.endsWith('.')) text = text.slice(0, -1)
+    res.json({ text, debug: { sentPrompt: debugPrompt, statusCode: upstream.status, rawResponse: data } })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router