@thinkable-labs/audio-enhancer 1.0.0

package/dist/elevenlabs.d.ts

@@ -0,0 +1,3 @@
+export declare function isolateAudio(audioPath: string, apiKey: string): Promise<Buffer>;
+export declare function changeVoice(audioBuffer: Buffer, voiceId: string, apiKey: string): Promise<Buffer>;
+//# sourceMappingURL=elevenlabs.d.ts.map

package/dist/elevenlabs.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isolateAudio = isolateAudio;
+exports.changeVoice = changeVoice;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+// ─── Audio Isolation ────────────────────────────────────────────────────────
+// POST https://api.elevenlabs.io/v1/audio-isolation
+// Multipart form: audio file
+// Returns: audio stream
+async function isolateAudio(audioPath, apiKey) {
+    const fileBuffer = fs.readFileSync(audioPath);
+    const fileName = path.basename(audioPath);
+    const boundary = `----FormBoundary${Date.now()}`;
+    const parts = [];
+    // File part
+    parts.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="audio"; filename="${fileName}"\r\n` +
+        `Content-Type: audio/mpeg\r\n\r\n`));
+    parts.push(fileBuffer);
+    parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+    const body = Buffer.concat(parts);
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: "api.elevenlabs.io",
+            path: "/v1/audio-isolation",
+            method: "POST",
+            headers: {
+                "xi-api-key": apiKey,
+                "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                "Content-Length": body.length,
+            },
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const result = Buffer.concat(chunks);
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`Audio isolation failed (${res.statusCode}): ${result.toString().substring(0, 200)}`));
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+// ─── Speech to Speech (Voice Change) ───────────────────────────────────────
+// POST https://api.elevenlabs.io/v1/speech-to-speech/{voice_id}
+// Multipart form: audio file + model_id
+// Returns: audio stream
+async function changeVoice(audioBuffer, voiceId, apiKey) {
+    const boundary = `----FormBoundary${Date.now()}`;
+    const parts = [];
+    // Audio file part
+    parts.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="audio"; filename="audio.mp3"\r\n` +
+        `Content-Type: audio/mpeg\r\n\r\n`));
+    parts.push(audioBuffer);
+    parts.push(Buffer.from("\r\n"));
+    // Model ID part
+    parts.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="model_id"\r\n\r\n` +
+        `eleven_english_sts_v2\r\n`));
+    parts.push(Buffer.from(`--${boundary}--\r\n`));
+    const body = Buffer.concat(parts);
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: "api.elevenlabs.io",
+            path: `/v1/speech-to-speech/${voiceId}`,
+            method: "POST",
+            headers: {
+                "xi-api-key": apiKey,
+                "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                "Content-Length": body.length,
+            },
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const result = Buffer.concat(chunks);
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`Voice change failed (${res.statusCode}): ${result.toString().substring(0, 200)}`));
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+//# sourceMappingURL=elevenlabs.js.map

package/dist/enhancer.d.ts

@@ -0,0 +1,34 @@
+export interface EnhanceOptions {
+    apiKey: string;
+    ffmpegPath: string;
+    outputDir: string;
+}
+export interface EnhanceItem {
+    videoPath: string;
+    voiceId: string;
+}
+export type ItemStatus = "pending" | "extracting" | "isolating" | "voice-changing" | "success" | "error";
+export interface ItemResult {
+    item: EnhanceItem;
+    videoName: string;
+    outputPath: string;
+    status: ItemStatus;
+    error?: string;
+}
+export interface BatchEnhanceResult {
+    results: ItemResult[];
+    totalCount: number;
+    successCount: number;
+    errorCount: number;
+}
+export type ProgressCallback = (update: {
+    current: number;
+    total: number;
+    videoName: string;
+    status: ItemStatus;
+    outputPath?: string;
+    error?: string;
+}) => void;
+export declare function enhanceVideo(item: EnhanceItem, options: EnhanceOptions): Promise<ItemResult>;
+export declare function enhanceBatch(items: EnhanceItem[], options: EnhanceOptions, onProgress?: ProgressCallback): Promise<BatchEnhanceResult>;
+//# sourceMappingURL=enhancer.d.ts.map

package/dist/enhancer.js

@@ -0,0 +1,162 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhanceVideo = enhanceVideo;
+exports.enhanceBatch = enhanceBatch;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const extractor_1 = require("./extractor");
+const elevenlabs_1 = require("./elevenlabs");
+// ─── Enhance a single video ────────────────────────────────────────────────
+async function enhanceVideo(item, options) {
+    const videoName = path.basename(item.videoPath, path.extname(item.videoPath));
+    const outputPath = path.join(options.outputDir, `${videoName}.mp3`);
+    let tempAudioPath = null;
+    try {
+        // Step 1: Extract audio from video
+        tempAudioPath = await (0, extractor_1.extractAudio)(item.videoPath, options.ffmpegPath);
+        // Step 2: Isolate voice (remove background noise)
+        const isolatedAudio = await (0, elevenlabs_1.isolateAudio)(tempAudioPath, options.apiKey);
+        // Step 3: Voice change
+        const finalAudio = await (0, elevenlabs_1.changeVoice)(isolatedAudio, item.voiceId, options.apiKey);
+        // Save final audio
+        if (!fs.existsSync(options.outputDir)) {
+            fs.mkdirSync(options.outputDir, { recursive: true });
+        }
+        fs.writeFileSync(outputPath, finalAudio);
+        return {
+            item,
+            videoName,
+            outputPath,
+            status: "success",
+        };
+    }
+    catch (err) {
+        return {
+            item,
+            videoName,
+            outputPath,
+            status: "error",
+            error: err?.message || String(err),
+        };
+    }
+    finally {
+        // Clean up temp file
+        if (tempAudioPath && fs.existsSync(tempAudioPath)) {
+            try {
+                fs.unlinkSync(tempAudioPath);
+            }
+            catch { }
+        }
+    }
+}
+// ─── Batch enhance ─────────────────────────────────────────────────────────
+async function enhanceBatch(items, options, onProgress) {
+    const results = [];
+    let successCount = 0;
+    let errorCount = 0;
+    if (!fs.existsSync(options.outputDir)) {
+        fs.mkdirSync(options.outputDir, { recursive: true });
+    }
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const videoName = path.basename(item.videoPath, path.extname(item.videoPath));
+        // Notify: extracting
+        onProgress?.({
+            current: i + 1,
+            total: items.length,
+            videoName,
+            status: "extracting",
+        });
+        let tempAudioPath = null;
+        try {
+            // Step 1: Extract audio
+            tempAudioPath = await (0, extractor_1.extractAudio)(item.videoPath, options.ffmpegPath);
+            // Notify: isolating
+            onProgress?.({
+                current: i + 1,
+                total: items.length,
+                videoName,
+                status: "isolating",
+            });
+            // Step 2: Isolate voice
+            const isolatedAudio = await (0, elevenlabs_1.isolateAudio)(tempAudioPath, options.apiKey);
+            // Notify: voice changing
+            onProgress?.({
+                current: i + 1,
+                total: items.length,
+                videoName,
+                status: "voice-changing",
+            });
+            // Step 3: Voice change
+            const finalAudio = await (0, elevenlabs_1.changeVoice)(isolatedAudio, item.voiceId, options.apiKey);
+            // Save
+            const outputPath = path.join(options.outputDir, `${videoName}.mp3`);
+            fs.writeFileSync(outputPath, finalAudio);
+            successCount++;
+            results.push({ item, videoName, outputPath, status: "success" });
+            onProgress?.({
+                current: i + 1,
+                total: items.length,
+                videoName,
+                status: "success",
+                outputPath,
+            });
+        }
+        catch (err) {
+            errorCount++;
+            const outputPath = path.join(options.outputDir, `${videoName}.mp3`);
+            const errorMsg = err?.message || String(err);
+            results.push({ item, videoName, outputPath, status: "error", error: errorMsg });
+            onProgress?.({
+                current: i + 1,
+                total: items.length,
+                videoName,
+                status: "error",
+                error: errorMsg,
+            });
+        }
+        finally {
+            if (tempAudioPath && fs.existsSync(tempAudioPath)) {
+                try {
+                    fs.unlinkSync(tempAudioPath);
+                }
+                catch { }
+            }
+        }
+    }
+    return { results, totalCount: items.length, successCount, errorCount };
+}
+//# sourceMappingURL=enhancer.js.map

package/dist/extractor.d.ts

@@ -0,0 +1,2 @@
+export declare function extractAudio(videoPath: string, ffmpegPath: string): Promise<string>;
+//# sourceMappingURL=extractor.d.ts.map

package/dist/extractor.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAudio = extractAudio;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+function extractAudio(videoPath, ffmpegPath) {
+    return new Promise((resolve, reject) => {
+        const outputPath = path.join(os.tmpdir(), `audio-enhance-${Date.now()}.mp3`);
+        (0, child_process_1.execFile)(ffmpegPath, [
+            "-i", videoPath,
+            "-vn", // no video
+            "-acodec", "libmp3lame",
+            "-ab", "192k",
+            "-ar", "44100",
+            "-y", // overwrite
+            outputPath,
+        ], { timeout: 60000 }, (error, _stdout, stderr) => {
+            if (error) {
+                reject(new Error(`FFmpeg failed: ${stderr || error.message}`));
+                return;
+            }
+            if (!fs.existsSync(outputPath)) {
+                reject(new Error("FFmpeg produced no output file"));
+                return;
+            }
+            resolve(outputPath);
+        });
+    });
+}
+//# sourceMappingURL=extractor.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { extractAudio } from "./extractor";
+export { isolateAudio, changeVoice } from "./elevenlabs";
+export { enhanceVideo, enhanceBatch } from "./enhancer";
+export type { EnhanceOptions, EnhanceItem, ItemStatus, ItemResult, BatchEnhanceResult, ProgressCallback, } from "./enhancer";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhanceBatch = exports.enhanceVideo = exports.changeVoice = exports.isolateAudio = exports.extractAudio = void 0;
+var extractor_1 = require("./extractor");
+Object.defineProperty(exports, "extractAudio", { enumerable: true, get: function () { return extractor_1.extractAudio; } });
+var elevenlabs_1 = require("./elevenlabs");
+Object.defineProperty(exports, "isolateAudio", { enumerable: true, get: function () { return elevenlabs_1.isolateAudio; } });
+Object.defineProperty(exports, "changeVoice", { enumerable: true, get: function () { return elevenlabs_1.changeVoice; } });
+var enhancer_1 = require("./enhancer");
+Object.defineProperty(exports, "enhanceVideo", { enumerable: true, get: function () { return enhancer_1.enhanceVideo; } });
+Object.defineProperty(exports, "enhanceBatch", { enumerable: true, get: function () { return enhancer_1.enhanceBatch; } });
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@thinkable-labs/audio-enhancer",
+  "version": "1.0.0",
+  "description": "Extract audio from video, isolate voice with ElevenLabs, apply voice change",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc"
+  },
+  "license": "UNLICENSED",
+  "dependencies": {
+    "form-data": "^4.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.9.3"
+  }
+}