recmp3-cli 1.0.0

package/dist/chunk-XGHYROLT.js

@@ -0,0 +1,481 @@
+#!/usr/bin/env node
+import { LocalWhisperProvider } from './chunk-NY5EJT5D.js';
+import { log } from './chunk-DDXRBIWU.js';
+import { ConfigError, TranscriptionError, NetworkError } from './chunk-NUWDWBJQ.js';
+import { existsSync, readFileSync } from 'fs';
+import { mkdir, writeFile, readFile } from 'fs/promises';
+import { join, dirname, basename, extname } from 'path';
+import { homedir } from 'os';
+import { z } from 'zod';
+
+function xdgConfigHome() {
+  return process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+}
+function xdgDataHome() {
+  return process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+}
+function appPaths() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const appSupport = join(
+      homedir(),
+      "Library",
+      "Application Support",
+      "recmp3"
+    );
+    return {
+      config: join(homedir(), "Library", "Preferences", "recmp3"),
+      data: appSupport,
+      recordings: join(appSupport, "recordings"),
+      transcripts: join(appSupport, "transcripts")
+    };
+  }
+  if (platform === "win32") {
+    const appData = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+    const base = join(appData, "recmp3");
+    return {
+      config: base,
+      data: base,
+      recordings: join(base, "recordings"),
+      transcripts: join(base, "transcripts")
+    };
+  }
+  const config = join(xdgConfigHome(), "recmp3");
+  const data = join(xdgDataHome(), "recmp3");
+  return {
+    config,
+    data,
+    recordings: join(data, "recordings"),
+    transcripts: join(data, "transcripts")
+  };
+}
+var paths = appPaths();
+var configFilePath = join(paths.config, "config.json");
+var RecmpConfigSchema = z.object({
+  version: z.literal(1).default(1),
+  provider: z.object({
+    default: z.enum(["groq", "openai", "local-whisper"]).default("groq"),
+    groq: z.object({
+      model: z.string().default("whisper-large-v3-turbo"),
+      baseUrl: z.string().optional(),
+      timeoutMs: z.number().optional()
+    }).optional(),
+    openai: z.object({
+      model: z.string().default("whisper-1"),
+      baseUrl: z.string().optional(),
+      timeoutMs: z.number().optional()
+    }).optional(),
+    local: z.object({
+      binPath: z.string().optional(),
+      modelPath: z.string().optional(),
+      language: z.string().optional()
+    }).optional()
+  }).default({}),
+  audio: z.object({
+    source: z.string().default("default"),
+    sampleRate: z.literal(16e3).default(16e3),
+    channels: z.literal(1).default(1),
+    format: z.literal("wav").default("wav")
+  }).default({}),
+  output: z.object({
+    recordingDir: z.string().optional(),
+    namePrefix: z.string().default("rec"),
+    keepAudio: z.boolean().default(true),
+    saveTranscriptToFile: z.boolean().default(true)
+  }).default({}),
+  transcription: z.object({
+    defaultLanguage: z.string().optional(),
+    chunking: z.object({
+      enabled: z.boolean().default(true),
+      chunkSeconds: z.number().default(600)
+    }).default({})
+  }).default({}),
+  ui: z.object({
+    clipboardOnTranscribe: z.boolean().default(true),
+    printOnTranscribe: z.boolean().default(true),
+    color: z.enum(["auto", "always", "never"]).default("auto")
+  }).default({}),
+  consent: z.object({
+    uploadsAcknowledged: z.boolean().default(false),
+    acknowledgedAt: z.string().optional()
+  }).default({})
+});
+
+// src/config/load.ts
+var _config = null;
+function applyEnvOverrides(config) {
+  const clone = structuredClone(config);
+  if (process.env.RECMP3_PROVIDER) {
+    const p = process.env.RECMP3_PROVIDER;
+    if (p === "groq" || p === "openai") clone.provider.default = p;
+  }
+  if (process.env.RECMP3_MODEL) {
+    const model = process.env.RECMP3_MODEL;
+    const provider = clone.provider.default;
+    if (provider === "groq") {
+      clone.provider.groq = { ...clone.provider.groq, model };
+    } else if (provider === "openai") {
+      clone.provider.openai = { ...clone.provider.openai, model };
+    }
+  }
+  if (process.env.RECMP3_SOURCE) {
+    clone.audio.source = process.env.RECMP3_SOURCE;
+  }
+  if (process.env.RECMP3_LANG) {
+    clone.transcription.defaultLanguage = process.env.RECMP3_LANG;
+  }
+  if (process.env.RECMP3_OUTDIR) {
+    clone.output.recordingDir = process.env.RECMP3_OUTDIR;
+  }
+  if (process.env.RECMP3_WHISPER_BIN) {
+    clone.provider.local = {
+      ...clone.provider.local,
+      binPath: process.env.RECMP3_WHISPER_BIN
+    };
+  }
+  if (process.env.RECMP3_WHISPER_MODEL) {
+    clone.provider.local = {
+      ...clone.provider.local,
+      modelPath: process.env.RECMP3_WHISPER_MODEL
+    };
+  }
+  return clone;
+}
+async function loadConfig() {
+  if (_config) return _config;
+  if (existsSync(".env")) {
+    const { config: dotenvConfig } = await import('dotenv');
+    dotenvConfig({ path: join(process.cwd(), ".env") });
+  }
+  let raw = {};
+  if (existsSync(configFilePath)) {
+    try {
+      raw = JSON.parse(readFileSync(configFilePath, "utf-8"));
+    } catch {
+      raw = {};
+    }
+  }
+  const parsed = RecmpConfigSchema.safeParse(raw);
+  const base = parsed.success ? parsed.data : RecmpConfigSchema.parse({});
+  if (!base.output.recordingDir) {
+    base.output.recordingDir = paths.recordings;
+  }
+  _config = applyEnvOverrides(base);
+  return _config;
+}
+function resetConfigCache() {
+  _config = null;
+}
+async function saveConfig(config) {
+  await mkdir(dirname(configFilePath), { recursive: true });
+  await writeFile(
+    configFilePath,
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf-8"
+  );
+  _config = config;
+}
+var ENV_VAR = {
+  groq: "GROQ_API_KEY",
+  openai: "OPENAI_API_KEY"
+};
+async function getApiKey(provider) {
+  const fromEnv = process.env[ENV_VAR[provider]];
+  if (fromEnv) return fromEnv;
+  const { getSecret } = await import('./keychain-CLYHGYS2.js');
+  return getSecret(ENV_VAR[provider]);
+}
+var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+var MAX_FILE_SIZE = 25 * 1024 * 1024;
+var SUPPORTED_FORMATS = [
+  "flac",
+  "m4a",
+  "mp3",
+  "mp4",
+  "mpeg",
+  "mpga",
+  "oga",
+  "ogg",
+  "wav",
+  "webm"
+];
+function getMimeType(filePath) {
+  const ext = extname(filePath).toLowerCase().slice(1);
+  const mimes = {
+    wav: "audio/wav",
+    mp3: "audio/mpeg",
+    mp4: "audio/mp4",
+    m4a: "audio/mp4",
+    ogg: "audio/ogg",
+    oga: "audio/ogg",
+    flac: "audio/flac",
+    webm: "audio/webm"
+  };
+  return mimes[ext] ?? "audio/wav";
+}
+var GroqProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = config.baseUrl ?? GROQ_BASE_URL;
+    this.timeoutMs = config.timeoutMs ?? 12e4;
+  }
+  config;
+  name = "groq";
+  maxFileSizeBytes = MAX_FILE_SIZE;
+  supportedFormats = SUPPORTED_FORMATS;
+  baseUrl;
+  timeoutMs;
+  async transcribe(input) {
+    const {
+      audioPath,
+      language,
+      prompt,
+      responseFormat = "verbose_json",
+      signal
+    } = input;
+    const t0 = Date.now();
+    log.info(
+      `Transcribing with Groq (${this.config.model}): ${basename(audioPath)}`
+    );
+    const audioBuffer = await readFile(audioPath);
+    const mimeType = getMimeType(audioPath);
+    const filename = basename(audioPath);
+    const form = new FormData();
+    const blob = new Blob([audioBuffer], { type: mimeType });
+    form.append("file", blob, filename);
+    form.append("model", this.config.model);
+    form.append("response_format", responseFormat);
+    if (language) form.append("language", language);
+    if (prompt) form.append("prompt", prompt);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const combinedSignal = signal ?? controller.signal;
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: form,
+        signal: combinedSignal
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new TranscriptionError(
+          `Transcription timed out after ${Math.round(this.timeoutMs / 1e3)}s.`
+        );
+      }
+      throw new NetworkError(
+        `Network error connecting to Groq: ${err instanceof Error ? err.message : String(err)}`
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new TranscriptionError(
+        `Groq API error ${response.status}: ${body || response.statusText}`,
+        response.status
+      );
+    }
+    const raw = await response.json();
+    const text = typeof raw === "string" ? raw : raw.text ?? "";
+    const latencyMs = Date.now() - t0;
+    log.info(`Transcription complete in ${(latencyMs / 1e3).toFixed(1)}s`);
+    return {
+      text: text.trim(),
+      language: raw.language,
+      durationSec: raw.duration,
+      segments: raw.segments?.map((s) => ({
+        startSec: s.start,
+        endSec: s.end,
+        text: s.text
+      })),
+      raw,
+      provider: "groq",
+      model: this.config.model,
+      latencyMs
+    };
+  }
+  async ping() {
+    const t0 = Date.now();
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: { Authorization: `Bearer ${this.config.apiKey}` },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) {
+        return { ok: false, error: `HTTP ${response.status}` };
+      }
+      return { ok: true, latencyMs: Date.now() - t0 };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+};
+var OPENAI_BASE_URL = "https://api.openai.com/v1";
+var MAX_FILE_SIZE2 = 25 * 1024 * 1024;
+var SUPPORTED_FORMATS2 = [
+  "flac",
+  "m4a",
+  "mp3",
+  "mp4",
+  "mpeg",
+  "mpga",
+  "oga",
+  "ogg",
+  "wav",
+  "webm"
+];
+function getMimeType2(filePath) {
+  const ext = extname(filePath).toLowerCase().slice(1);
+  const mimes = {
+    wav: "audio/wav",
+    mp3: "audio/mpeg",
+    m4a: "audio/mp4",
+    ogg: "audio/ogg",
+    flac: "audio/flac"
+  };
+  return mimes[ext] ?? "audio/wav";
+}
+var OpenAIProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = config.baseUrl ?? OPENAI_BASE_URL;
+    this.timeoutMs = config.timeoutMs ?? 12e4;
+  }
+  config;
+  name = "openai";
+  maxFileSizeBytes = MAX_FILE_SIZE2;
+  supportedFormats = SUPPORTED_FORMATS2;
+  baseUrl;
+  timeoutMs;
+  async transcribe(input) {
+    const {
+      audioPath,
+      language,
+      prompt,
+      responseFormat = "verbose_json",
+      signal
+    } = input;
+    const t0 = Date.now();
+    log.info(
+      `Transcribing with OpenAI (${this.config.model}): ${basename(audioPath)}`
+    );
+    const audioBuffer = await readFile(audioPath);
+    const form = new FormData();
+    const blob = new Blob([audioBuffer], { type: getMimeType2(audioPath) });
+    form.append("file", blob, basename(audioPath));
+    form.append("model", this.config.model);
+    form.append("response_format", responseFormat);
+    if (language) form.append("language", language);
+    if (prompt) form.append("prompt", prompt);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.config.apiKey}` },
+        body: form,
+        signal: signal ?? controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      throw new NetworkError(
+        `Network error connecting to OpenAI: ${err instanceof Error ? err.message : String(err)}`
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new TranscriptionError(
+        `OpenAI API error ${response.status}: ${body || response.statusText}`,
+        response.status
+      );
+    }
+    const raw = await response.json();
+    return {
+      text: (typeof raw === "string" ? raw : raw.text ?? "").trim(),
+      language: raw.language,
+      durationSec: raw.duration,
+      segments: raw.segments?.map((s) => ({
+        startSec: s.start,
+        endSec: s.end,
+        text: s.text
+      })),
+      raw,
+      provider: "openai",
+      model: this.config.model,
+      latencyMs: Date.now() - t0
+    };
+  }
+  async ping() {
+    const t0 = Date.now();
+    try {
+      const r = await fetch(`${this.baseUrl}/models`, {
+        headers: { Authorization: `Bearer ${this.config.apiKey}` },
+        signal: AbortSignal.timeout(1e4)
+      });
+      return r.ok ? { ok: true, latencyMs: Date.now() - t0 } : { ok: false, error: `HTTP ${r.status}` };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+};
+
+// src/transcription/registry.ts
+function providerUploads(name) {
+  return name === "groq" || name === "openai";
+}
+async function createProvider(config) {
+  const providerName = config.provider.default;
+  if (providerName === "groq") {
+    const apiKey = await getApiKey("groq");
+    if (!apiKey) {
+      throw new ConfigError(
+        "GROQ_API_KEY is not set.\n  Set it with: export GROQ_API_KEY=your_key\n  Or run: recmp3 config set-key groq --key your_key"
+      );
+    }
+    const groqConfig = config.provider.groq;
+    return new GroqProvider({
+      apiKey,
+      model: groqConfig?.model ?? "whisper-large-v3-turbo",
+      baseUrl: groqConfig?.baseUrl,
+      timeoutMs: groqConfig?.timeoutMs
+    });
+  }
+  if (providerName === "openai") {
+    const apiKey = await getApiKey("openai");
+    if (!apiKey) {
+      throw new ConfigError(
+        "OPENAI_API_KEY is not set.\n  Set it with: export OPENAI_API_KEY=your_key\n  Or run: recmp3 config set-key openai --key your_key"
+      );
+    }
+    const openaiConfig = config.provider.openai;
+    return new OpenAIProvider({
+      apiKey,
+      model: openaiConfig?.model ?? "whisper-1",
+      baseUrl: openaiConfig?.baseUrl,
+      timeoutMs: openaiConfig?.timeoutMs
+    });
+  }
+  if (providerName === "local-whisper") {
+    return new LocalWhisperProvider(config.provider.local ?? {});
+  }
+  throw new ConfigError(
+    `Unknown provider: "${providerName}". Valid options: groq, openai, local-whisper.`
+  );
+}
+
+export { RecmpConfigSchema, configFilePath, createProvider, getApiKey, loadConfig, paths, providerUploads, resetConfigCache, saveConfig };