@slycode/slycode 0.2.10 → 0.2.12

package/dist/web/package.json

@@ -11,13 +11,15 @@
     "lint": "eslint"
   },
   "dependencies": {
-    "@aws-sdk/client-transcribe-streaming": "^3.1012.0",
+    "@aws-sdk/client-s3": "^3.1013.0",
+    "@aws-sdk/client-transcribe": "^3.1013.0",
     "@tailwindcss/typography": "^0.5.19",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-web-links": "^0.12.0",
     "@xterm/xterm": "^6.0.0",
     "croner": "^10.0.1",
     "diff": "^8.0.3",
+    "ebml": "^3.0.0",
     "next": "16.1.6",
     "openai": "^6.23.0",
     "react": "19.2.3",

package/dist/web/src/app/api/transcribe/route.ts

@@ -5,15 +5,17 @@ import path from 'path';
 import { execFile } from 'child_process';
 import { getSlycodeRoot } from '@/lib/paths';
 import {
-  TranscribeStreamingClient,
-  StartStreamTranscriptionCommand,
-  type AudioStream,
+  TranscribeClient,
+  StartTranscriptionJobCommand,
+  GetTranscriptionJobCommand,
   type LanguageCode,
-  type MediaEncoding,
-} from '@aws-sdk/client-transcribe-streaming';
+} from '@aws-sdk/client-transcribe';
+import { S3Client, PutObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+
 
 let openaiClient: OpenAI | null = null;
-let transcribeClient: TranscribeStreamingClient | null = null;
+let transcribeClient: TranscribeClient | null = null;
+let s3Client: S3Client | null = null;
 let envLoaded = false;
 let envCache: Record<string, string> = {};
 
@@ -49,13 +51,20 @@ async function getClient(): Promise<OpenAI> {
   return openaiClient;
 }
 
-function getTranscribeClient(region?: string): TranscribeStreamingClient {
+function getTranscribeClient(region?: string): TranscribeClient {
   if (!transcribeClient) {
-    transcribeClient = new TranscribeStreamingClient(region ? { region } : {});
+    transcribeClient = new TranscribeClient(region ? { region } : {});
   }
   return transcribeClient;
 }
 
+function getS3Client(region?: string): S3Client {
+  if (!s3Client) {
+    s3Client = new S3Client(region ? { region } : {});
+  }
+  return s3Client;
+}
+
 function execAsync(cmd: string, args: string[], options: Record<string, unknown>): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile(cmd, args, { ...options, windowsHide: true }, (error, stdout, stderr) => {
@@ -91,75 +100,77 @@ async function transcribeLocal(audioBuffer: Buffer, ext: string, cliPath: string
   }
 }
 
-async function transcribeAwsStreaming(audioBuffer: Buffer, ext: string, region: string, language: string): Promise<string> {
-  const client = getTranscribeClient(region || undefined);
-
-  const isOgg = ext === 'ogg' || ext === 'oga';
-
-  let streamBuffer: Buffer;
-  let mediaEncoding: MediaEncoding;
-  let sampleRate: number;
-  let pcmPath: string | null = null;
-
-  if (isOgg) {
-    // OGG/Opus can be sent directly
-    streamBuffer = audioBuffer;
-    mediaEncoding = 'ogg-opus';
-    sampleRate = 48000;
-  } else {
-    // Convert WebM/MP4 to PCM via ffmpeg
-    const tmpDir = process.env.TMPDIR || '/tmp';
-    const tmpFile = path.join(tmpDir, `transcribe_${Date.now()}.${ext}`);
-    pcmPath = tmpFile.replace(/\.[^.]+$/, '.pcm');
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
 
-    try {
-      await fs.writeFile(tmpFile, audioBuffer);
-      await execAsync('ffmpeg', [
-        '-i', tmpFile, '-ar', '16000', '-ac', '1', '-f', 's16le', '-y', pcmPath,
-      ], { timeout: 30_000 });
-      streamBuffer = await fs.readFile(pcmPath);
-      await fs.unlink(tmpFile).catch(() => {});
-    } catch (err) {
-      await fs.unlink(tmpFile).catch(() => {});
-      throw new Error(`ffmpeg conversion to PCM failed: ${(err as Error).message}`);
-    }
-    mediaEncoding = 'pcm';
-    sampleRate = 16000;
-  }
-
-  const chunkSize = 4096;
-  async function* audioStream(): AsyncGenerator<AudioStream> {
-    for (let offset = 0; offset < streamBuffer.length; offset += chunkSize) {
-      yield { AudioEvent: { AudioChunk: streamBuffer.subarray(offset, offset + chunkSize) } };
-    }
-  }
+async function transcribeAwsBatch(
+  audioBuffer: Buffer,
+  ext: string,
+  region: string,
+  language: string,
+  s3Bucket: string,
+): Promise<string> {
+  const transcribe = getTranscribeClient(region || undefined);
+  const s3 = getS3Client(region || undefined);
+
+  // Batch API accepts webm, ogg, mp4 directly — no conversion needed
+  const mediaFormat = ext === 'webm' ? 'webm' : (ext === 'oga' || ext === 'ogg') ? 'ogg' : ext === 'mp4' ? 'mp4' : 'wav';
+  const jobName = `stt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const s3Key = `stt-temp/${jobName}.${ext}`;
+
+  // Upload audio to S3
+  await s3.send(new PutObjectCommand({
+    Bucket: s3Bucket,
+    Key: s3Key,
+    Body: audioBuffer,
+  }));
 
   try {
-    const response = await client.send(new StartStreamTranscriptionCommand({
+    // Start transcription job
+    await transcribe.send(new StartTranscriptionJobCommand({
+      TranscriptionJobName: jobName,
       LanguageCode: language as LanguageCode,
-      MediaEncoding: mediaEncoding,
-      MediaSampleRateHertz: sampleRate,
-      AudioStream: audioStream(),
+      MediaFormat: mediaFormat,
+      Media: { MediaFileUri: `s3://${s3Bucket}/${s3Key}` },
     }));
 
-    const parts: string[] = [];
-    if (response.TranscriptResultStream) {
-      for await (const event of response.TranscriptResultStream) {
-        if (event.TranscriptEvent?.Transcript?.Results) {
-          for (const result of event.TranscriptEvent.Transcript.Results) {
-            if (!result.IsPartial && result.Alternatives?.[0]?.Transcript) {
-              parts.push(result.Alternatives[0].Transcript);
-            }
-          }
-        }
+    // Poll for completion
+    let status = 'IN_PROGRESS';
+    let resultUri = '';
+    while (status === 'IN_PROGRESS' || status === 'QUEUED') {
+      await sleep(1500);
+      const result = await transcribe.send(new GetTranscriptionJobCommand({
+        TranscriptionJobName: jobName,
+      }));
+      status = result.TranscriptionJob?.TranscriptionJobStatus || 'FAILED';
+      if (status === 'COMPLETED') {
+        resultUri = result.TranscriptionJob?.Transcript?.TranscriptFileUri || '';
+      }
+      if (status === 'FAILED') {
+        const reason = result.TranscriptionJob?.FailureReason || 'Unknown error';
+        throw new Error(`AWS Transcribe job failed: ${reason}`);
       }
     }
 
-    return parts.join(' ').trim();
-  } finally {
-    if (pcmPath) {
-      await fs.unlink(pcmPath).catch(() => {});
+    if (!resultUri) {
+      throw new Error('AWS Transcribe completed but no transcript URI returned');
     }
+
+    // Fetch transcript JSON from the presigned URI
+    const response = await fetch(resultUri);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch transcript: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json() as {
+      results?: { transcripts?: Array<{ transcript?: string }> };
+    };
+    return (data.results?.transcripts?.[0]?.transcript || '').trim();
+  } finally {
+    // Clean up S3 object
+    try {
+      await s3.send(new DeleteObjectCommand({ Bucket: s3Bucket, Key: s3Key }));
+    } catch { /* ignore cleanup errors */ }
   }
 }
 
@@ -192,8 +203,13 @@ export async function POST(request: Request) {
     if (backend === 'aws-transcribe') {
       const region = process.env.AWS_TRANSCRIBE_REGION || env.AWS_TRANSCRIBE_REGION || '';
       const language = process.env.AWS_TRANSCRIBE_LANGUAGE || env.AWS_TRANSCRIBE_LANGUAGE || 'en-AU';
+      const s3Bucket = process.env.AWS_TRANSCRIBE_S3_BUCKET || env.AWS_TRANSCRIBE_S3_BUCKET || '';
+
+      if (!s3Bucket) {
+        return NextResponse.json({ error: 'AWS Transcribe not configured: set AWS_TRANSCRIBE_S3_BUCKET' }, { status: 401 });
+      }
 
-      const text = await transcribeAwsStreaming(buffer, ext, region, language);
+      const text = await transcribeAwsBatch(buffer, ext, region, language, s3Bucket);
       return NextResponse.json({ text });
     }
 

package/dist/web/src/components/VoiceControlBar.tsx

@@ -105,6 +105,7 @@ export function VoiceControlBar({
               <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
             </svg>
           </button>
+
         </>
       )}
 

package/dist/web/src/lib/webm-to-ogg-opus.ts

@@ -0,0 +1,254 @@
+/**
+ * WebM/Opus → OGG/Opus remuxer (pure JS, no ffmpeg).
+ *
+ * Extracts Opus packets from a WebM container and wraps them in a valid
+ * OGG Opus stream per RFC 7845. Only handles single-track audio-only WebM
+ * from browser MediaRecorder — not arbitrary Matroska files.
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { Decoder: EbmlDecoder } = require('ebml');
+
+// --- OGG CRC-32 (polynomial 0x04C11DB7, no bit reversal) ---
+
+const crcTable = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+  let r = i << 24;
+  for (let j = 0; j < 8; j++) {
+    r = r & 0x80000000 ? ((r << 1) ^ 0x04C11DB7) : (r << 1);
+    r = r >>> 0; // keep unsigned 32-bit
+  }
+  crcTable[i] = r;
+}
+
+function oggCrc32(data: Uint8Array): number {
+  let crc = 0;
+  for (let i = 0; i < data.length; i++) {
+    crc = ((crc << 8) ^ crcTable[((crc >>> 24) ^ data[i]) & 0xff]) >>> 0;
+  }
+  return crc;
+}
+
+// --- Opus packet duration parsing ---
+
+function getOpusPacketDuration48k(packet: Uint8Array): number {
+  if (packet.length < 1) return 960; // fallback: 20ms
+
+  const toc = packet[0];
+  const config = (toc >> 3) & 0x1f;
+  const frameCountCode = toc & 0x03;
+
+  // Frame size in 48kHz samples based on config number
+  let frameSamples: number;
+  if (config <= 11) {
+    // SILK: 10ms, 20ms, 40ms, 60ms
+    frameSamples = [480, 960, 1920, 2880][config % 4];
+  } else if (config <= 15) {
+    // Hybrid: 10ms, 20ms
+    frameSamples = [480, 960][(config - 12) % 2];
+  } else {
+    // CELT: 2.5ms, 5ms, 10ms, 20ms
+    frameSamples = [120, 240, 480, 960][(config - 16) % 4];
+  }
+
+  // Number of frames per packet
+  let frameCount: number;
+  switch (frameCountCode) {
+    case 0: frameCount = 1; break;
+    case 1: frameCount = 2; break;
+    case 2: frameCount = 2; break;
+    case 3:
+      frameCount = packet.length >= 2 ? (packet[1] & 0x3f) : 1;
+      break;
+    default: frameCount = 1;
+  }
+
+  return frameSamples * frameCount;
+}
+
+// --- OGG page writer ---
+
+function writeOggPage(
+  serialNumber: number,
+  sequenceNumber: number,
+  granulePosition: bigint,
+  flags: number, // 0x02 = BOS, 0x04 = EOS, 0x01 = continued
+  packets: Uint8Array[],
+): Buffer {
+  // Build segment table: each packet is split into 255-byte segments + remainder
+  const segmentSizes: number[] = [];
+  for (const pkt of packets) {
+    let remaining = pkt.length;
+    while (remaining >= 255) {
+      segmentSizes.push(255);
+      remaining -= 255;
+    }
+    segmentSizes.push(remaining); // final segment (0-254), 0 means exactly N*255 bytes
+  }
+
+  const payloadSize = packets.reduce((sum, p) => sum + p.length, 0);
+  const headerSize = 27 + segmentSizes.length;
+  const pageSize = headerSize + payloadSize;
+  const page = Buffer.alloc(pageSize);
+
+  // Capture pattern
+  page.write('OggS', 0);
+  // Version
+  page[4] = 0;
+  // Header type flags
+  page[5] = flags;
+  // Granule position (64-bit little-endian)
+  page.writeBigInt64LE(granulePosition, 6);
+  // Serial number
+  page.writeUInt32LE(serialNumber, 14);
+  // Page sequence number
+  page.writeUInt32LE(sequenceNumber, 18);
+  // CRC placeholder (filled after)
+  page.writeUInt32LE(0, 22);
+  // Number of segments
+  page[26] = segmentSizes.length;
+  // Segment table
+  for (let i = 0; i < segmentSizes.length; i++) {
+    page[27 + i] = segmentSizes[i];
+  }
+  // Payload
+  let offset = headerSize;
+  for (const pkt of packets) {
+    Buffer.from(pkt).copy(page, offset);
+    offset += pkt.length;
+  }
+
+  // Compute and write CRC
+  const crc = oggCrc32(page);
+  page.writeUInt32LE(crc, 22);
+
+  return page;
+}
+
+// --- WebM parsing ---
+
+interface WebmParseResult {
+  opusHead: Buffer;
+  codecDelay: number; // nanoseconds
+  packets: Uint8Array[];
+}
+
+function parseWebmOpus(webmBuffer: Buffer): WebmParseResult {
+  const decoder = new EbmlDecoder();
+  let opusHead: Buffer | null = null;
+  let codecDelay = 0;
+  let audioTrack = 1;
+  const packets: Uint8Array[] = [];
+
+  // Track whether we're inside a TrackEntry to associate CodecPrivate with the right track
+  let inTrackEntry = false;
+  let currentTrackNumber = 0;
+  let currentCodecId = '';
+
+  const events: Array<[string, Record<string, unknown>]> = [];
+  decoder.on('data', (chunk: [string, Record<string, unknown>]) => events.push(chunk));
+  decoder.write(webmBuffer);
+  decoder.end();
+
+  for (const [type, tag] of events) {
+    const name = tag.name as string;
+
+    if (type === 'start' && name === 'TrackEntry') {
+      inTrackEntry = true;
+      currentTrackNumber = 0;
+      currentCodecId = '';
+    }
+
+    if (type === 'end' && name === 'TrackEntry') {
+      if (currentCodecId === 'A_OPUS' && currentTrackNumber > 0) {
+        audioTrack = currentTrackNumber;
+      }
+      inTrackEntry = false;
+    }
+
+    if (type === 'tag' && inTrackEntry) {
+      if (name === 'TrackNumber') {
+        currentTrackNumber = tag.value as number;
+      }
+      if (name === 'CodecID') {
+        currentCodecId = tag.value as string;
+      }
+      if (name === 'CodecPrivate') {
+        opusHead = Buffer.from(tag.data as Uint8Array);
+      }
+      if (name === 'CodecDelay') {
+        codecDelay = tag.value as number;
+      }
+    }
+
+    if (type === 'tag' && name === 'SimpleBlock') {
+      const track = tag.track as number;
+      const payload = tag.payload as Uint8Array | null;
+      if (track === audioTrack && payload && payload.length > 0) {
+        packets.push(Uint8Array.from(payload));
+      }
+    }
+  }
+
+  if (!opusHead) {
+    throw new Error('No Opus CodecPrivate (OpusHead) found in WebM');
+  }
+  if (packets.length === 0) {
+    throw new Error('No Opus audio packets found in WebM');
+  }
+
+  return { opusHead, codecDelay, packets };
+}
+
+// --- Main remux function ---
+
+export function remuxWebmToOgg(webmBuffer: Buffer): Buffer {
+  const { opusHead, codecDelay, packets } = parseWebmOpus(webmBuffer);
+
+  const serialNumber = Math.floor(Math.random() * 0xFFFFFFFF);
+  let sequenceNumber = 0;
+
+  // Pre-skip: convert CodecDelay from nanoseconds to 48kHz samples
+  // Also read pre-skip from OpusHead itself (bytes 10-11, little-endian uint16)
+  const opusHeadPreSkip = opusHead.readUInt16LE(10);
+  const preSkip = codecDelay > 0
+    ? Math.round(codecDelay / 1e9 * 48000)
+    : opusHeadPreSkip;
+
+  // If CodecDelay-derived pre-skip differs from OpusHead, patch OpusHead
+  const finalOpusHead = Buffer.from(opusHead);
+  if (preSkip !== opusHeadPreSkip) {
+    finalOpusHead.writeUInt16LE(preSkip, 10);
+  }
+
+  const pages: Buffer[] = [];
+
+  // Page 0: OpusHead (BOS)
+  pages.push(writeOggPage(serialNumber, sequenceNumber++, BigInt(0), 0x02, [finalOpusHead]));
+
+  // Page 1: OpusTags
+  const vendor = Buffer.from('remux');
+  const opusTags = Buffer.alloc(8 + 4 + vendor.length + 4);
+  opusTags.write('OpusTags', 0);
+  opusTags.writeUInt32LE(vendor.length, 8);
+  vendor.copy(opusTags, 12);
+  opusTags.writeUInt32LE(0, 12 + vendor.length); // zero user comments
+  pages.push(writeOggPage(serialNumber, sequenceNumber++, BigInt(0), 0, [opusTags]));
+
+  // Data pages: one packet per page for simplicity
+  let granulePosition = BigInt(preSkip); // starts at pre-skip per RFC 7845
+  for (let i = 0; i < packets.length; i++) {
+    const duration = getOpusPacketDuration48k(packets[i]);
+    granulePosition += BigInt(duration);
+    const isLast = i === packets.length - 1;
+    pages.push(writeOggPage(
+      serialNumber,
+      sequenceNumber++,
+      granulePosition,
+      isLast ? 0x04 : 0, // EOS on last page
+      [packets[i]],
+    ));
+  }
+
+  return Buffer.concat(pages);
+}