Release 0.2.0

.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
+}

CHANGELOG.md

@@ -1,5 +1,244 @@
 # Changelog
 
+## [0.2.0] (2026-02-02)
+
+### ⚠️ Breaking Changes
+
+- **Removed meta wrapper from all classes** - Access properties directly instead of through `.meta`
+- **Removed Job-based pattern** - All async operations now use async/await directly
+- **Upload methods now return media objects directly** - No longer returns Job instances
+- **Removed exports:** `Job`, `TranscriptJob`, `UploadJob`, `IndexJob`, `SceneIndexJob`, `ExtractScenesJob`
+
+### New Modules
+
+#### Capture Sessions (Desktop Recording)
+
+Backend orchestration for desktop capture sessions with native binary support:
+
+- **CaptureSession** (`cap-xxx`) - Server-side lifecycle object for capture runs
+- **CaptureClient** - Desktop client for recording mic, system audio, and display
+- **Session Token Authentication** - Secure client auth without exposing API keys
+- **WebSocket Integration** - Real-time transcript and indexing event delivery
+
+```typescript
+// Backend: Create session and generate token
+const cap = await coll.createCaptureSession({
+  endUserId: 'user_abc',
+  callbackUrl: 'https://example.com/webhook',
+});
+const token = await conn.generateClientToken(86400);
+
+// Desktop client: Start capture
+import { CaptureClient } from 'videodb/capture';
+const client = new CaptureClient({ sessionToken: token });
+await client.requestPermission('microphone');
+await client.startCaptureSession({ sessionId: cap.id, channels: [...] });
+```
+
+**Supported channels:**
+- `mic:default` (audio)
+- `system_audio:default` (audio)
+- `display:1`, `display:2`, ... (video)
+
+#### Meeting Module
+
+Record and manage meetings with bot integration:
+
+```typescript
+const meeting = await coll.recordMeeting({
+  meetingUrl: 'https://meet.google.com/xxx',
+  botName: 'RecorderBot',
+  callbackUrl: 'https://example.com/webhook',
+});
+```
+
+#### RTStream Module
+
+Real-time media streams for live capture and indexing:
+
+- **RTStream** (`rts-xxx`) - Real-time media stream per channel
+- **RTStreamSceneIndex** - Visual scene indexing on live streams
+- **RTStreamSearchResult** / **RTStreamShot** - Search results from RTStreams
+
+```typescript
+const mic = cap.getRtstream('mic:default');
+await mic.startTranscript({ socketId: ws.connectionId });
+
+const scenes = await display.indexVisuals({
+  batchConfig: { type: 'time', value: 2, frameCount: 2 },
+  prompt: 'Describe the scene',
+  socketId: ws.connectionId,
+});
+await scenes.start();
+```
+
+#### Editor Module
+
+Comprehensive video editing with Timeline, Track, and asset classes:
+
+```typescript
+import {
+  EditorTimeline,
+  Track,
+  Clip,
+  EditorVideoAsset,
+  CaptionAsset,
+} from 'videodb';
+
+const timeline = new EditorTimeline(conn);
+const track = new Track();
+track.addItem(new Clip({ asset: new EditorVideoAsset({ assetId: video.id }) }));
+timeline.addTrack(track);
+```
+
+**New asset classes:**
+- `EditorVideoAsset`, `EditorImageAsset`, `EditorAudioAsset`, `EditorTextAsset`, `CaptionAsset`
+
+**Helper classes:**
+- `Offset`, `Crop`, `Transition`, `Font`, `Border`, `Shadow`, `Background`, `Alignment`, `FontStyling`, `BorderAndShadow`, `Positioning`
+
+**Enums:**
+- `AssetType`, `Fit`, `Position`, `Filter`, `TextAlignment`, `HorizontalAlignment`, `VerticalAlignment`, `CaptionBorderStyle`, `CaptionAlignment`, `CaptionAnimation`
+
+#### WebSocket Module
+
+Real-time event streaming for transcript and indexing:
+
+```typescript
+const ws = await conn.connectWebsocket();
+await ws.connect();
+
+for await (const ev of ws.stream()) {
+  if (ev.channel === 'transcript') console.log(ev.data?.text);
+  if (ev.channel === 'scene_index') console.log(ev.data);
+}
+```
+
+### New Methods
+
+#### Video
+
+- `getTranscriptText(start?, end?)` - Get plain text transcript
+- `generateTranscript(force?)` - Generate transcript via POST
+- `translateTranscript(language, additionalNotes?, callbackUrl?)` - Translate transcript
+- `removeStorage()` - Remove video storage
+- `getThumbnails()` - Get all thumbnails as Image objects
+- `insertVideo(video, timestamp)` - Insert another video at timestamp
+- `reframe(options?)` - Reframe video to new aspect ratio
+- `smartVerticalReframe(options?)` - Object-aware vertical reframing
+- `download(name?)` - Download video from stream URL
+- `getMeeting()` - Get associated meeting info
+- `clip(prompt, contentType, modelName)` - Generate clip from prompt
+
+#### Audio
+
+- `getTranscript(start?, end?, segmenter?, length?, force?)` - Get timestamped transcript
+- `getTranscriptText(start?, end?)` - Get plain text transcript
+- `generateTranscript(force?, languageCode?)` - Generate transcript
+- `generateUrl()` - Generate signed URL
+
+#### Image
+
+- `generateUrl()` - Generate signed URL
+
+#### Collection
+
+- `delete()` - Delete the collection
+- `makePublic()` / `makePrivate()` - Toggle collection visibility
+- `generateVideo(prompt, duration?, callbackUrl?)` - Generate video from prompt
+- `generateImage(prompt, aspectRatio?, callbackUrl?)` - Generate image from prompt
+- `generateMusic(prompt, duration?, callbackUrl?)` - Generate music from prompt
+- `generateSoundEffect(prompt, duration?, config?, callbackUrl?)` - Generate sound effect
+- `generateVoice(text, voiceName?, config?, callbackUrl?)` - Generate voice from text
+- `generateText(prompt, modelName?, responseType?)` - Generate text with GenAI
+- `dubVideo(videoId, languageCode, callbackUrl?)` - Dub video to another language
+- `searchTitle(query)` - Search by video title
+- `connectRTStream(url, name, ...)` - Connect to real-time stream
+- `getRTStream(id)` - Get RTStream by ID
+- `listRTStreams(options?)` - List all RTStreams
+- `recordMeeting(config)` - Record a meeting
+- `getMeeting(meetingId)` - Get meeting by ID
+- `createCaptureSession(config)` - Create capture session
+
+#### Connection
+
+- `recordMeeting(config)` - Record meeting to default collection
+- `getMeeting(meetingId)` - Get meeting by ID
+- `youtubeSearch(query, resultThreshold?, duration?)` - Search YouTube
+- `download(streamLink, name)` - Download from stream link
+- `transcode(source, callbackUrl, mode?, videoConfig?, audioConfig?)` - Transcode video
+- `getTranscodeDetails(jobId)` - Get transcode job details
+- `createEvent(eventPrompt, label)` - Create RTStream event
+- `listEvents()` - List all RTStream events
+- `checkUsage()` - Check account usage
+- `getInvoices()` - Get list of invoices
+- `connectWebsocket(collectionId?)` - Connect to WebSocket service
+- `getCaptureSession(sessionId, collectionId?)` - Get capture session
+- `listCaptureSessions(collectionId?, config?)` - List capture sessions
+- `createCaptureSession(config)` - Create capture session (convenience)
+- `generateClientToken(expiresIn?)` - Generate client token for capture
+
+#### Scene
+
+- Added `metadata` property for scene metadata
+
+### New Types & Exports
+
+#### Capture Session Types
+
+```typescript
+export {
+  ConnectionConfig,
+  CaptureSessionStatus,
+  ChannelType,
+  PermissionKind,
+  TranscriptStatusValues,
+  WebSocketChannel,
+  BatchConfig,
+  IndexVisualsConfig,
+  IndexSpokenWordsConfig,
+  AlertConfig,
+  // ... and more
+} from 'videodb';
+```
+
+#### Editor Types
+
+```typescript
+export {
+  OffsetConfig,
+  CropConfig,
+  TransitionConfig,
+  FontConfig,
+  EditorVideoAssetConfig,
+  ClipConfig,
+  // ... and more
+} from 'videodb';
+```
+
+#### Additional Exports
+
+- `MeetingStatus`, `Segmenter`, `SegmentationType`
+- `ReframeMode`, `ReframePreset`
+- `TranscodeMode`, `ResizeMode`, `MediaType`
+- `TextStyle`, `TextStyleConfig`
+- `SpokenIndex`, `SceneIndex`, `SceneData`, `AlertData`
+
+### Internal Improvements
+
+- **Centralized snake_case/camelCase conversion** - Handled in HttpClient for consistent API communication
+- **Simplified error handling** - Proper exception propagation with typed errors
+- **Reduced bundle size** - Removed Job infrastructure (~400 lines)
+- **Dual authentication support** - API key (backend) and session token (client) modes
+
+### New Error Types
+
+- `CaptureError` - Capture session related errors
+- `BinaryError` - Native binary communication errors
+- `PermissionError` - System permission errors
+
+---
+
 ## [0.1.3] (2026-01-19)
 
 ### Added

lib/installer.js

@@ -0,0 +1,134 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const crypto = require('crypto');
+const tar = require('tar');
+
+class Installer {
+    constructor(config) {
+        this.config = config;
+        this.platform = process.platform;
+        this.arch = process.arch;
+        this.binDir = path.join(__dirname, '..', 'bin');
+    }
+
+    isPlatformSupported() {
+        const platformKey = `${this.platform}-${this.arch}`;
+        return this.config.checksums && this.config.checksums[platformKey];
+    }
+
+    getDownloadUrl() {
+        const platformKey = `${this.platform}-${this.arch}`;
+        return `${this.config.baseUrl}/v${this.config.version}/recorder-${platformKey}.tar.gz`;
+    }
+
+    getExpectedChecksum() {
+        const platformKey = `${this.platform}-${this.arch}`;
+        return this.config.checksums[platformKey];
+    }
+
+    async downloadFile(url, destPath) {
+        return new Promise((resolve, reject) => {
+            const file = fs.createWriteStream(destPath);
+            https.get(url, (response) => {
+                if (response.statusCode === 302 || response.statusCode === 301) {
+                    file.close();
+                    fs.unlinkSync(destPath);
+                    this.downloadFile(response.headers.location, destPath)
+                        .then(resolve)
+                        .catch(reject);
+                    return;
+                }
+                if (response.statusCode !== 200) {
+                    file.close();
+                    fs.unlinkSync(destPath);
+                    reject(new Error(`Failed to download: ${response.statusCode}`));
+                    return;
+                }
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+            }).on('error', (err) => {
+                fs.unlink(destPath, () => { });
+                reject(err);
+            });
+        });
+    }
+
+    async verifyChecksum(filePath, expectedChecksum) {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('sha256');
+            const stream = fs.createReadStream(filePath);
+            stream.on('data', data => hash.update(data));
+            stream.on('end', () => {
+                const actualChecksum = hash.digest('hex');
+                if (actualChecksum !== expectedChecksum) {
+                    reject(new Error(`Checksum mismatch: expected ${expectedChecksum}, got ${actualChecksum}`));
+                } else {
+                    resolve(true);
+                }
+            });
+            stream.on('error', reject);
+        });
+    }
+
+    async install() {
+        console.log(`Installing VideoDB Recorder for ${this.platform}-${this.arch}...`);
+
+        if (!this.isPlatformSupported()) {
+            const platformKey = `${this.platform}-${this.arch}`;
+            console.warn(`Platform ${platformKey} is not currently supported.`);
+            console.warn(`Supported platforms: ${Object.keys(this.config.checksums || {}).join(', ')}`);
+            console.warn('Skipping binary installation.');
+            return;
+        }
+
+        if (!fs.existsSync(this.binDir)) {
+            fs.mkdirSync(this.binDir, { recursive: true });
+        }
+
+        const platformKey = `${this.platform}-${this.arch}`;
+        const tarPath = path.join(this.binDir, `recorder-${platformKey}.tar.gz`);
+        const binaryName = this.platform === 'win32' ? 'recorder.exe' : 'recorder';
+        const binaryPath = path.join(this.binDir, binaryName);
+        const url = this.getDownloadUrl();
+
+        if (fs.existsSync(binaryPath)) {
+            console.log('Binary already installed, skipping download.');
+            return;
+        }
+
+        try {
+            console.log(`Downloading from ${url}...`);
+            await this.downloadFile(url, tarPath);
+
+            console.log('Verifying checksum...');
+            await this.verifyChecksum(tarPath, this.getExpectedChecksum());
+            console.log('Checksum verified.');
+
+            console.log('Extracting binary...');
+            await tar.x({
+                file: tarPath,
+                cwd: this.binDir
+            });
+
+            fs.unlinkSync(tarPath);
+
+            if (this.platform !== 'win32') {
+                fs.chmodSync(binaryPath, 0o755);
+            }
+
+            console.log('Installation complete!');
+        } catch (error) {
+            console.error('Installation failed:', error.message);
+            if (fs.existsSync(tarPath)) {
+                fs.unlinkSync(tarPath);
+            }
+            process.exit(1);
+        }
+    }
+}
+
+module.exports = Installer;