@slycode/slycode 0.2.5 → 0.2.6

package/dist/web/package.json

@@ -11,6 +11,7 @@
     "lint": "eslint"
   },
   "dependencies": {
+    "@aws-sdk/client-transcribe-streaming": "^3.1012.0",
     "@tailwindcss/typography": "^0.5.19",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-web-links": "^0.12.0",

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

@@ -4,8 +4,16 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { execFile } from 'child_process';
 import { getSlycodeRoot } from '@/lib/paths';
+import {
+  TranscribeStreamingClient,
+  StartStreamTranscriptionCommand,
+  type AudioStream,
+  type LanguageCode,
+  type MediaEncoding,
+} from '@aws-sdk/client-transcribe-streaming';
 
 let openaiClient: OpenAI | null = null;
+let transcribeClient: TranscribeStreamingClient | null = null;
 let envLoaded = false;
 let envCache: Record<string, string> = {};
 
@@ -41,6 +49,13 @@ async function getClient(): Promise<OpenAI> {
   return openaiClient;
 }
 
+function getTranscribeClient(region?: string): TranscribeStreamingClient {
+  if (!transcribeClient) {
+    transcribeClient = new TranscribeStreamingClient(region ? { region } : {});
+  }
+  return transcribeClient;
+}
+
 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) => {
@@ -76,6 +91,78 @@ 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');
+
+    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) } };
+    }
+  }
+
+  try {
+    const response = await client.send(new StartStreamTranscriptionCommand({
+      LanguageCode: language as LanguageCode,
+      MediaEncoding: mediaEncoding,
+      MediaSampleRateHertz: sampleRate,
+      AudioStream: audioStream(),
+    }));
+
+    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);
+            }
+          }
+        }
+      }
+    }
+
+    return parts.join(' ').trim();
+  } finally {
+    if (pcmPath) {
+      await fs.unlink(pcmPath).catch(() => {});
+    }
+  }
+}
+
 export async function POST(request: Request) {
   try {
     const formData = await request.formData();
@@ -102,7 +189,15 @@ export async function POST(request: Request) {
       return NextResponse.json({ text });
     }
 
-    // OpenAI API path
+    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 text = await transcribeAwsStreaming(buffer, ext, region, language);
+      return NextResponse.json({ text });
+    }
+
+    // OpenAI API path (default)
     let client: OpenAI;
     try {
       client = await getClient();