recmp3-cli 1.0.0

package/dist/keychain-CLYHGYS2.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export { deleteSecret, getSecret, keychainAvailable, setSecret } from './chunk-FNZ6ZCOK.js';
+import './chunk-DDXRBIWU.js';

package/dist/linux-pulse-AROLYZNB.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import { findFfmpeg } from './chunk-7NR5CU7W.js';
+import { AudioCaptureError } from './chunk-NUWDWBJQ.js';
+import { execFile, spawn } from 'child_process';
+import { stat } from 'fs/promises';
+import { promisify } from 'util';
+
+var execFileAsync = promisify(execFile);
+var LinuxPulseCapture = class {
+  process = null;
+  startedAt = null;
+  outputPath = null;
+  recording = false;
+  async start(opts) {
+    const ffmpeg = await findFfmpeg();
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-f",
+      "pulse",
+      "-i",
+      opts.source,
+      "-ac",
+      String(opts.channels),
+      "-ar",
+      String(opts.sampleRate),
+      "-c:a",
+      "pcm_s16le",
+      "-y",
+      opts.outputPath
+    ];
+    this.outputPath = opts.outputPath;
+    this.startedAt = /* @__PURE__ */ new Date();
+    const proc = spawn(ffmpeg, args, { stdio: ["pipe", "pipe", "pipe"] });
+    this.process = proc;
+    this.recording = true;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => resolve(), 500);
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        this.recording = false;
+        reject(new AudioCaptureError(`Failed to start ffmpeg: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        this.recording = false;
+      });
+      let stderrBuf = "";
+      proc.stderr?.on("data", (chunk) => {
+        stderrBuf += chunk.toString();
+      });
+      setTimeout(() => {
+        if (!proc.pid) {
+          clearTimeout(timer);
+          reject(
+            new AudioCaptureError(
+              `ffmpeg failed to start. Check audio source: "${opts.source}"`
+            )
+          );
+        }
+      }, 200);
+    });
+    if (!proc.pid) {
+      throw new AudioCaptureError(
+        `ffmpeg failed to start. Run 'recmp3 sources' to list available audio sources.`
+      );
+    }
+  }
+  async stop() {
+    if (!this.process || !this.recording) {
+      throw new AudioCaptureError("Not currently recording.");
+    }
+    const proc = this.process;
+    const startedAt = this.startedAt ?? /* @__PURE__ */ new Date();
+    const outputPath = this.outputPath;
+    const endedAt = /* @__PURE__ */ new Date();
+    this.recording = false;
+    this.process = null;
+    this.startedAt = null;
+    this.outputPath = null;
+    await new Promise((resolve, reject) => {
+      proc.on("close", () => resolve());
+      proc.on("error", reject);
+      try {
+        proc.stdin?.write("q");
+        proc.stdin?.end();
+      } catch {
+        proc.kill("SIGTERM");
+      }
+      const forceKill = setTimeout(() => {
+        proc.kill("SIGTERM");
+      }, 5e3);
+      proc.on("close", () => clearTimeout(forceKill));
+    });
+    const fileStat = await stat(outputPath).catch(() => ({ size: 0 }));
+    const durationSec = (endedAt.getTime() - startedAt.getTime()) / 1e3;
+    return {
+      path: outputPath,
+      durationSec,
+      sizeBytes: fileStat.size,
+      startedAt,
+      endedAt
+    };
+  }
+  isRecording() {
+    return this.recording;
+  }
+  async dispose() {
+    if (this.process) {
+      try {
+        this.process.stdin?.end();
+        this.process.kill("SIGTERM");
+      } catch {
+      }
+      this.process = null;
+    }
+    this.recording = false;
+  }
+};
+var LinuxPulseCaptureFactory = class {
+  create() {
+    return new LinuxPulseCapture();
+  }
+  async listSources() {
+    try {
+      const { stdout } = await execFileAsync("pactl", [
+        "list",
+        "sources",
+        "short"
+      ]);
+      const sources = [];
+      for (const line of stdout.trim().split("\n")) {
+        const parts = line.split("	");
+        if (parts.length < 2) continue;
+        const id = parts[1];
+        if (!id) continue;
+        const isMonitor = id.includes(".monitor");
+        sources.push({
+          id,
+          label: isMonitor ? `${id} (system audio monitor)` : id,
+          isDefault: id === "default" || false
+        });
+      }
+      const hasDefault = sources.some((s) => s.id === "default");
+      if (!hasDefault) {
+        sources.unshift({
+          id: "default",
+          label: "default (system default)",
+          isDefault: true
+        });
+      }
+      return sources;
+    } catch {
+      try {
+        const ffmpeg = await findFfmpeg();
+        const { stderr } = await execFileAsync(ffmpeg, [
+          "-sources",
+          "pulse",
+          "-hide_banner"
+        ]);
+        const sources = [
+          { id: "default", label: "default (system default)", isDefault: true }
+        ];
+        for (const line of stderr.split("\n")) {
+          const match = line.match(/^\s+(\S+)\s/);
+          if (match)
+            sources.push({ id: match[1], label: match[1], isDefault: false });
+        }
+        return sources;
+      } catch {
+        return [
+          { id: "default", label: "default (system default)", isDefault: true }
+        ];
+      }
+    }
+  }
+  defaultSource() {
+    return process.env.RECMP3_SOURCE ?? "default";
+  }
+};
+
+export { LinuxPulseCapture, LinuxPulseCaptureFactory };

package/dist/local-whisper-VH26RX7Y.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export { LocalWhisperProvider } from './chunk-NY5EJT5D.js';
+import './chunk-DDXRBIWU.js';
+import './chunk-NUWDWBJQ.js';

package/dist/mac-avfoundation-COPCFRZT.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import { findFfmpeg } from './chunk-7NR5CU7W.js';
+import { AudioCaptureError } from './chunk-NUWDWBJQ.js';
+import { execFile, spawn } from 'child_process';
+import { stat } from 'fs/promises';
+import { promisify } from 'util';
+
+var execFileAsync = promisify(execFile);
+var MacAvFoundationCapture = class {
+  process = null;
+  startedAt = null;
+  outputPath = null;
+  recording = false;
+  async start(opts) {
+    const ffmpeg = await findFfmpeg();
+    const source = opts.source.startsWith(":") ? opts.source : `:${opts.source}`;
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-f",
+      "avfoundation",
+      "-i",
+      source,
+      "-ac",
+      String(opts.channels),
+      "-ar",
+      String(opts.sampleRate),
+      "-c:a",
+      "pcm_s16le",
+      "-y",
+      opts.outputPath
+    ];
+    this.outputPath = opts.outputPath;
+    this.startedAt = /* @__PURE__ */ new Date();
+    const proc = spawn(ffmpeg, args, { stdio: ["pipe", "pipe", "pipe"] });
+    this.process = proc;
+    this.recording = true;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => resolve(), 800);
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        this.recording = false;
+        reject(
+          new AudioCaptureError(
+            `Failed to start ffmpeg: ${err.message}. Grant microphone access in System Settings \u2192 Privacy & Security \u2192 Microphone.`
+          )
+        );
+      });
+    });
+  }
+  async stop() {
+    if (!this.process || !this.recording)
+      throw new AudioCaptureError("Not recording.");
+    const proc = this.process;
+    const startedAt = this.startedAt ?? /* @__PURE__ */ new Date();
+    const outputPath = this.outputPath;
+    const endedAt = /* @__PURE__ */ new Date();
+    this.recording = false;
+    this.process = null;
+    await new Promise((resolve) => {
+      proc.on("close", resolve);
+      try {
+        proc.stdin?.write("q");
+        proc.stdin?.end();
+      } catch {
+        proc.kill("SIGTERM");
+      }
+      setTimeout(() => proc.kill("SIGTERM"), 5e3);
+    });
+    const fileStat = await stat(outputPath).catch(() => ({ size: 0 }));
+    return {
+      path: outputPath,
+      durationSec: (endedAt.getTime() - startedAt.getTime()) / 1e3,
+      sizeBytes: fileStat.size,
+      startedAt,
+      endedAt
+    };
+  }
+  isRecording() {
+    return this.recording;
+  }
+  async dispose() {
+    if (this.process) {
+      try {
+        this.process.kill("SIGTERM");
+      } catch {
+      }
+      this.process = null;
+    }
+    this.recording = false;
+  }
+};
+var MacAvFoundationFactory = class {
+  create() {
+    return new MacAvFoundationCapture();
+  }
+  async listSources() {
+    try {
+      const ffmpeg = await findFfmpeg();
+      const { stderr } = await execFileAsync(ffmpeg, [
+        "-f",
+        "avfoundation",
+        "-list_devices",
+        "true",
+        "-i",
+        ""
+      ]);
+      const sources = [];
+      let inAudioSection = false;
+      for (const line of stderr.split("\n")) {
+        if (line.includes("AVFoundation audio devices:")) {
+          inAudioSection = true;
+          continue;
+        }
+        if (!inAudioSection) continue;
+        const match = line.match(/\[(\d+)\] (.+)/);
+        if (match) {
+          sources.push({
+            id: match[1],
+            label: match[2],
+            isDefault: match[1] === "0"
+          });
+        }
+      }
+      return sources.length > 0 ? sources : [{ id: "0", label: "Default audio device", isDefault: true }];
+    } catch {
+      return [{ id: "0", label: "Default audio device", isDefault: true }];
+    }
+  }
+  defaultSource() {
+    return process.env.RECMP3_SOURCE ?? "0";
+  }
+};
+
+export { MacAvFoundationCapture, MacAvFoundationFactory };

package/dist/registry-D5SOVUEJ.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export { createProvider, providerUploads } from './chunk-XGHYROLT.js';
+import './chunk-NY5EJT5D.js';
+import './chunk-DDXRBIWU.js';
+import './chunk-NUWDWBJQ.js';

package/dist/windows-dshow-O2GU4ZLR.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { findFfmpeg } from './chunk-7NR5CU7W.js';
+import { AudioCaptureError } from './chunk-NUWDWBJQ.js';
+import { execFile, spawn } from 'child_process';
+import { stat } from 'fs/promises';
+import { promisify } from 'util';
+
+var execFileAsync = promisify(execFile);
+var WindowsDshowCapture = class {
+  process = null;
+  startedAt = null;
+  outputPath = null;
+  recording = false;
+  async start(opts) {
+    const ffmpeg = await findFfmpeg();
+    const deviceName = opts.source === "default" ? await this.getDefaultDevice() : opts.source;
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-f",
+      "dshow",
+      "-i",
+      `audio=${deviceName}`,
+      "-ac",
+      String(opts.channels),
+      "-ar",
+      String(opts.sampleRate),
+      "-c:a",
+      "pcm_s16le",
+      "-y",
+      opts.outputPath
+    ];
+    this.outputPath = opts.outputPath;
+    this.startedAt = /* @__PURE__ */ new Date();
+    const proc = spawn(ffmpeg, args, { stdio: ["pipe", "pipe", "pipe"] });
+    this.process = proc;
+    this.recording = true;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => resolve(), 1e3);
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        this.recording = false;
+        reject(
+          new AudioCaptureError(
+            `Failed to start recording: ${err.message}. Run 'recmp3 sources' to list available devices.`
+          )
+        );
+      });
+    });
+  }
+  async getDefaultDevice() {
+    const sources = await this.listSources();
+    const first = sources.find((s) => !s.label.includes("monitor")) ?? sources[0];
+    return first?.id ?? "Microphone";
+  }
+  async stop() {
+    if (!this.process || !this.recording)
+      throw new AudioCaptureError("Not recording.");
+    const proc = this.process;
+    const startedAt = this.startedAt ?? /* @__PURE__ */ new Date();
+    const outputPath = this.outputPath;
+    const endedAt = /* @__PURE__ */ new Date();
+    this.recording = false;
+    this.process = null;
+    await new Promise((resolve) => {
+      proc.on("close", resolve);
+      try {
+        proc.stdin?.write("q");
+        proc.stdin?.end();
+      } catch {
+        proc.kill("SIGTERM");
+      }
+      setTimeout(() => proc.kill("SIGTERM"), 5e3);
+    });
+    const fileStat = await stat(outputPath).catch(() => ({ size: 0 }));
+    return {
+      path: outputPath,
+      durationSec: (endedAt.getTime() - startedAt.getTime()) / 1e3,
+      sizeBytes: fileStat.size,
+      startedAt,
+      endedAt
+    };
+  }
+  isRecording() {
+    return this.recording;
+  }
+  async dispose() {
+    if (this.process) {
+      try {
+        this.process.kill("SIGTERM");
+      } catch {
+      }
+      this.process = null;
+    }
+    this.recording = false;
+  }
+  async listSources() {
+    try {
+      const ffmpeg = await findFfmpeg();
+      const { stderr } = await execFileAsync(ffmpeg, [
+        "-list_devices",
+        "true",
+        "-f",
+        "dshow",
+        "-i",
+        "dummy"
+      ]);
+      const sources = [];
+      let inAudioSection = false;
+      for (const line of stderr.split("\n")) {
+        if (line.includes("DirectShow audio devices")) {
+          inAudioSection = true;
+          continue;
+        }
+        if (line.includes("DirectShow video devices")) {
+          inAudioSection = false;
+          continue;
+        }
+        if (!inAudioSection) continue;
+        const match = line.match(/"([^"]+)"/);
+        if (match)
+          sources.push({
+            id: match[1],
+            label: match[1],
+            isDefault: sources.length === 0
+          });
+      }
+      return sources;
+    } catch {
+      return [
+        { id: "Microphone", label: "Microphone (default)", isDefault: true }
+      ];
+    }
+  }
+};
+var WindowsDshowFactory = class {
+  capture = new WindowsDshowCapture();
+  create() {
+    return new WindowsDshowCapture();
+  }
+  async listSources() {
+    return this.capture.listSources();
+  }
+  defaultSource() {
+    return process.env.RECMP3_SOURCE ?? "default";
+  }
+};
+
+export { WindowsDshowCapture, WindowsDshowFactory };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "recmp3-cli",
+  "version": "1.0.0",
+  "description": "Record audio, transcribe with AI, output developer-ready prompts — for humans and AI agents, from a single terminal command.",
+  "type": "module",
+  "bin": {
+    "recmp3": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "LICENSE-COMMERCIAL.md",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src",
+    "format": "biome format --write src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "clipboardy": "^4.0.0",
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.5",
+    "env-paths": "^3.0.0",
+    "ink": "^5.1.0",
+    "ora": "^8.1.1",
+    "picocolors": "^1.1.1",
+    "react": "^18.3.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.3",
+    "@types/node": "^20.16.11",
+    "@types/react": "^18.3.11",
+    "@vitest/coverage-v8": "4.1.8",
+    "msw": "^2.4.9",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.3",
+    "vitest": "^4.1.8"
+  },
+  "optionalDependencies": {
+    "keytar": "^7.9.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "AGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aedneth/recmp3-cli.git"
+  },
+  "keywords": [
+    "cli",
+    "audio",
+    "recording",
+    "transcription",
+    "whisper",
+    "groq",
+    "developer-tools",
+    "vibecoding",
+    "mcp",
+    "ai-agent",
+    "agent-native"
+  ]
+}