levante 0.1.4 → 0.2.1

package/scripts/companion/server.mjs

@@ -0,0 +1,258 @@
+import { createServer } from 'node:http';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname, extname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WebSocketServer } from 'ws';
+import { createState } from './state.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const uiDir = resolve(__dirname, 'ui');
+
+const outputDir = process.env.COMPANION_OUTPUT_DIR || '/tmp';
+const timestamp = process.env.COMPANION_TIMESTAMP || Date.now().toString();
+const hasOpenAIKey = !!process.env.OPENAI_API_KEY;
+
+const MIME_TYPES = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+};
+
+const state = createState();
+const clients = new Set();
+
+function broadcast(msg) {
+  const data = JSON.stringify(msg);
+  for (const ws of clients) {
+    if (ws.readyState === 1) ws.send(data);
+  }
+}
+
+function broadcastState() {
+  broadcast({ type: 'state:update', state: state.getState() });
+}
+
+const server = createServer((req, res) => {
+  if (req.url === '/api/capabilities') {
+    res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+    res.end(JSON.stringify({ hasOpenAIKey }));
+    return;
+  }
+
+  let filePath;
+  if (req.url === '/' || req.url === '/companion') {
+    filePath = resolve(uiDir, 'companion.html');
+  } else {
+    filePath = resolve(uiDir, req.url.slice(1));
+  }
+
+  if (!filePath.startsWith(uiDir) || !existsSync(filePath)) {
+    res.writeHead(404);
+    res.end('Not found');
+    return;
+  }
+
+  const ext = extname(filePath);
+  const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+  res.writeHead(200, { 'Content-Type': contentType, 'Access-Control-Allow-Origin': '*' });
+  res.end(readFileSync(filePath));
+});
+
+const wss = new WebSocketServer({ server });
+
+wss.on('connection', (ws) => {
+  clients.add(ws);
+  ws.send(JSON.stringify({ type: 'state:update', state: state.getState() }));
+
+  ws.on('message', (raw, isBinary) => {
+    // Binary messages are audio chunks from MediaRecorder (background Whisper mode)
+    if (isBinary || (raw instanceof Buffer && !raw.toString('utf-8').startsWith('{'))) {
+      handleAudioChunk(raw);
+      return;
+    }
+
+    let msg;
+    try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+    switch (msg.type) {
+      case 'control:pause':
+        state.pause();
+        broadcastState();
+        break;
+      case 'control:resume':
+        state.resume(msg.cursorSegmentId);
+        broadcastState();
+        break;
+      case 'control:stop':
+        state.stop();
+        broadcastState();
+        break;
+      case 'transcript:segment':
+        if (msg.segment) { state.addSegment(msg.segment); broadcastState(); }
+        break;
+      case 'transcript:edit':
+        if (msg.id && msg.text !== undefined) { state.editSegment(msg.id, msg.text); broadcastState(); }
+        break;
+      case 'transcript:tag':
+        if (msg.id && msg.tags) { state.tagSegment(msg.id, msg.tags); broadcastState(); }
+        break;
+      case 'transcript:interim':
+        for (const client of clients) {
+          if (client !== ws && client.readyState === 1) {
+            client.send(JSON.stringify({ type: 'transcript:interim', text: msg.text }));
+          }
+        }
+        break;
+      case 'engine:set':
+        if (msg.engine) { state.setEngine(msg.engine); broadcastState(); }
+        break;
+      case 'save':
+        handleSave();
+        break;
+      case 'save-and-exit':
+        // User clicked Save & Close in companion — save, then notify parent
+        handleSave();
+        // Forward to parent via stdout so it can kill codegen
+        console.log(JSON.stringify({ type: 'save-and-exit' }));
+        break;
+      case 'codegen:closed':
+        // Parent notifies that codegen browser was closed
+        state.stop();
+        broadcast({ type: 'codegen:closed' });
+        broadcastState();
+        break;
+    }
+  });
+
+  ws.on('close', () => { clients.delete(ws); });
+});
+
+// --- Whisper transcription for background audio chunks ---
+let audioChunkBuffer = [];
+let whisperProcessing = false;
+
+async function handleAudioChunk(chunk) {
+  if (!hasOpenAIKey || state.getStatus() !== 'recording') return;
+
+  audioChunkBuffer.push(chunk);
+
+  // Process accumulated chunks (debounce to avoid too many API calls)
+  if (!whisperProcessing) {
+    whisperProcessing = true;
+    // Small delay to batch nearby chunks
+    setTimeout(() => processWhisperQueue(), 500);
+  }
+}
+
+async function processWhisperQueue() {
+  if (audioChunkBuffer.length === 0) {
+    whisperProcessing = false;
+    return;
+  }
+
+  const chunks = audioChunkBuffer.splice(0);
+  const blob = Buffer.concat(chunks);
+
+  try {
+    const elapsed = state.getElapsed();
+    const text = await transcribeWithWhisper(blob);
+    if (text && text.trim()) {
+      const segStart = elapsed - 3; // approximate: chunk was ~3s ago
+      state.addSegment({
+        text: text.trim(),
+        start: Math.max(0, segStart),
+        end: elapsed,
+        tags: [],
+        edited: false,
+      });
+      broadcastState();
+    }
+  } catch (err) {
+    console.error('Whisper transcription error:', err.message);
+  }
+
+  whisperProcessing = false;
+  // Process any chunks that arrived while we were transcribing
+  if (audioChunkBuffer.length > 0) {
+    whisperProcessing = true;
+    setTimeout(() => processWhisperQueue(), 200);
+  }
+}
+
+async function transcribeWithWhisper(audioBuffer) {
+  // Build multipart/form-data manually (avoid dependency on form-data package)
+  const boundary = '----WhisperBoundary' + Date.now();
+  const preamble = [
+    `--${boundary}`,
+    'Content-Disposition: form-data; name="file"; filename="chunk.webm"',
+    'Content-Type: audio/webm',
+    '',
+    '',
+  ].join('\r\n');
+  const modelField = [
+    '',
+    `--${boundary}`,
+    'Content-Disposition: form-data; name="model"',
+    '',
+    'whisper-1',
+    `--${boundary}--`,
+    '',
+  ].join('\r\n');
+
+  const body = Buffer.concat([
+    Buffer.from(preamble),
+    audioBuffer,
+    Buffer.from(modelField),
+  ]);
+
+  const res = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+    },
+    body,
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Whisper API ${res.status}: ${err}`);
+  }
+
+  const data = await res.json();
+  return data.text || '';
+}
+
+function handleSave() {
+  const transcriptPath = resolve(outputDir, `transcript-${timestamp}.json`);
+  state.saveTranscript(transcriptPath);
+  console.log(JSON.stringify({ type: 'transcript:saved', path: transcriptPath }));
+  broadcastState();
+}
+
+const COMPANION_PORT = parseInt(process.env.COMPANION_PORT || '6391', 10);
+
+server.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    console.log(JSON.stringify({ type: 'server-error', error: `Port ${COMPANION_PORT} is already in use. Is another recording session running?` }));
+    process.exit(1);
+  }
+  throw err;
+});
+
+server.listen(COMPANION_PORT, '127.0.0.1', () => {
+  const { port } = server.address();
+  console.log(JSON.stringify({ type: 'server-started', port, url: `http://localhost:${port}` }));
+});
+
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (data) => {
+  const trimmed = data.trim();
+  if (trimmed === 'save') handleSave();
+  else if (trimmed === 'stop') { state.stop(); broadcastState(); }
+  else if (trimmed === 'pause') { state.pause(); broadcastState(); }
+  else if (trimmed === 'resume') { state.resume(); broadcastState(); }
+});
+
+process.on('SIGTERM', () => { wss.close(); server.close(); process.exit(0); });

package/scripts/companion/state.mjs

@@ -0,0 +1,97 @@
+import { writeFileSync } from 'node:fs';
+
+export function createState() {
+  let status = 'recording';
+  let engine = 'webspeech';
+  let segments = [];
+  let lastResumeTime = Date.now();
+  let accumulatedMs = 0;
+  let insertAfterSegmentId = null;
+  let nextSegmentIndex = 0;
+
+  function getElapsed() {
+    if (status === 'recording') {
+      return (accumulatedMs + (Date.now() - lastResumeTime)) / 1000;
+    }
+    return accumulatedMs / 1000;
+  }
+
+  function getState() {
+    return { status, elapsed: getElapsed(), segments, engine };
+  }
+
+  function pause() {
+    if (status !== 'recording') return getState();
+    accumulatedMs += Date.now() - lastResumeTime;
+    status = 'paused';
+    return getState();
+  }
+
+  function resume(cursorSegmentId) {
+    if (status !== 'paused') return getState();
+    insertAfterSegmentId = cursorSegmentId || null;
+    lastResumeTime = Date.now();
+    status = 'recording';
+    return getState();
+  }
+
+  function stop() {
+    if (status === 'recording') {
+      accumulatedMs += Date.now() - lastResumeTime;
+    }
+    status = 'stopped';
+    return getState();
+  }
+
+  function addSegment(segment) {
+    const seg = {
+      ...segment,
+      id: segment.id || `seg-${String(nextSegmentIndex++).padStart(3, '0')}`,
+    };
+
+    if (insertAfterSegmentId) {
+      const idx = segments.findIndex((s) => s.id === insertAfterSegmentId);
+      if (idx !== -1) {
+        segments.splice(idx + 1, 0, seg);
+        insertAfterSegmentId = seg.id;
+        return getState();
+      }
+    }
+
+    segments.push(seg);
+    return getState();
+  }
+
+  function editSegment(id, text) {
+    const seg = segments.find((s) => s.id === id);
+    if (seg) { seg.text = text; seg.edited = true; }
+    return getState();
+  }
+
+  function tagSegment(id, tags) {
+    const seg = segments.find((s) => s.id === id);
+    if (seg) seg.tags = tags;
+    return getState();
+  }
+
+  function setEngine(eng) { engine = eng; }
+
+  function saveTranscript(outputPath) {
+    const data = {
+      engine,
+      duration: getElapsed(),
+      segments: segments.map((s) => ({
+        id: s.id, text: s.text, start: s.start, end: s.end,
+        tags: s.tags || [], edited: s.edited || false,
+      })),
+    };
+    writeFileSync(outputPath, JSON.stringify(data, null, 2));
+    return outputPath;
+  }
+
+  return {
+    getState, getElapsed, pause, resume, stop,
+    addSegment, editSegment, tagSegment,
+    setEngine, saveTranscript, getStatus: () => status,
+  };
+}