voxflow 1.15.0 → 1.15.2

package/lib/commands/auth-cmds.js

@@ -0,0 +1,358 @@
+/**
+ * VoxFlow CLI — Auth commands (login, logout, status, dashboard, clone)
+ */
+
+const { getToken, clearToken, getTokenInfo, getFreshTokenInfo, terminalOtpLogin, buildPrintOnlyLoginUrl, acceptManualAuthPayload, readCachedToken } = require('../core/auth');
+const { API_BASE, DASHBOARD_URL } = require('../core/config');
+const { parseFlag, parseBoolFlag, runWithRetry } = require('../core/args');
+const { request } = require('../core/http');
+
+const VOICE_CLONE_URL = 'https://www.voxflow.studio/app#voice-clone';
+
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+// ─── Handlers ───────────────────────────────────────────────────────────────
+
+async function handleLogin(args) {
+  const api = parseFlag(args, '--api') || API_BASE;
+  const useOtp = parseBoolFlag(args, '--otp');
+  const printUrl = parseBoolFlag(args, '--print-url');
+  const pastePayload = parseFlag(args, '--paste');
+
+  // ─── Non-interactive mode #1: print URL only ──────────────────────────
+  // Designed for AI agents (WorkBuddy / sandboxed Claude Code / etc.) that
+  // can't reliably handle interactive stdin paste. Agent runs this, gets
+  // the URL, hands it to the user, user logs in, page shows JSON payload,
+  // user copies & pastes back to agent, agent runs `--paste <json>`.
+  if (printUrl) {
+    const url = buildPrintOnlyLoginUrl(api);
+    process.stdout.write(`${url}\n`);
+    if (process.stderr.isTTY) {
+      process.stderr.write('\nNext step: open this URL in a browser, complete login,\n');
+      process.stderr.write('then paste the auth payload back via:\n');
+      process.stderr.write('  voxflow login --paste \'<json-payload>\'\n\n');
+    }
+    return;
+  }
+
+  // ─── Non-interactive mode #2: accept payload from flag or stdin ──────
+  // `--paste -` reads the JSON payload from stdin. Useful when the JSON is
+  // long, contains characters bash quoting would mangle, or when an AI
+  // agent wants to pipe `echo $payload | voxflow login --paste -` without
+  // worrying about embedding special chars in argv.
+  if (pastePayload != null) {
+    let payload = pastePayload;
+    if (pastePayload === '-') {
+      payload = await readAllStdin();
+      if (!payload || !payload.trim()) {
+        console.error('\x1b[31m✗ Login failed: stdin is empty. Pipe the JSON payload, e.g. echo \'{...}\' | voxflow login --paste -\x1b[0m');
+        process.exit(1);
+      }
+    }
+    const result = acceptManualAuthPayload(payload, api);
+    if (!result.ok) {
+      console.error(`\x1b[31m✗ Login failed: ${result.message}\x1b[0m`);
+      process.exit(1);
+    }
+    console.log(`\x1b[32m✓ Logged in as ${result.info.email}\x1b[0m`);
+    console.log(`Token expires: ${result.info.expiresAt}`);
+    console.log(`API: ${result.info.api}`);
+    return;
+  }
+
+  // ─── Interactive modes (existing behavior) ────────────────────────────
+  if (useOtp) {
+    // Terminal-only OTP login — no browser needed
+    await terminalOtpLogin(api);
+  } else {
+    console.log('Logging in...');
+    const token = await getToken({ api, force: true });
+    // Suppress unused variable — token is cached by getToken
+    void token;
+  }
+
+  const info = getTokenInfo();
+  if (info) {
+    console.log(`\x1b[32mLogged in as ${info.email}\x1b[0m`);
+    console.log(`Token expires: ${info.expiresAt}`);
+    console.log(`API: ${info.api}`);
+  }
+}
+
+function handleLogout() {
+  clearToken();
+  console.log('Logged out. Token cache cleared.');
+}
+
+/**
+ * Fetch current quota for the cached token. Returns the parsed quota object
+ * on success, or null if the request fails for any reason — callers MUST
+ * tolerate null (we never want a network blip to break `voxflow status`).
+ */
+async function fetchQuota(api) {
+  try {
+    const cached = readCachedToken();
+    if (!cached) return null;
+    const { status, data } = await request(`${api}/api/user/quota`, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${cached.access_token}` },
+      timeoutMs: 5000,
+    });
+    if (status !== 200 || data?.code !== 'success') return null;
+    return data.data || null;
+  } catch {
+    return null;
+  }
+}
+
+function formatQuotaLines(q) {
+  // Compact, easy-to-scan: tier on one line, used/remaining on another.
+  // We deliberately don't try to convert to dollars or hours — credits are
+  // the metric users see in the dashboard, keep them as the unit of truth.
+  const lines = [];
+  const tier = q.subscription_tier || 'free';
+  const monthlyTotal = q.monthly || 0;
+  const used = q.used || 0;
+  const monthlyRemaining = Math.max(0, monthlyTotal - used);
+  const bonus = q.bonus || 0;
+  const total = q.remaining != null ? q.remaining : (monthlyRemaining + bonus);
+  lines.push(`Tier:    ${tier}`);
+  lines.push(`Quota:   ${total.toLocaleString()} credits remaining`);
+  lines.push(`         ${monthlyRemaining.toLocaleString()} monthly + ${bonus.toLocaleString()} bonus (used ${used.toLocaleString()} this cycle)`);
+  if (q.days_until_reset != null) {
+    lines.push(`         monthly resets in ${q.days_until_reset} day${q.days_until_reset === 1 ? '' : 's'}`);
+  }
+  return lines;
+}
+
+async function handleStatus(args = []) {
+  const jsonOutput = parseBoolFlag(args, '--json');
+  const info = await getFreshTokenInfo();
+
+  // Fetch quota in parallel-ish — we already have the token if info is set.
+  const quota = info ? await fetchQuota(info.api || API_BASE) : null;
+
+  if (jsonOutput) {
+    const payload = info
+      ? {
+        loggedIn: true,
+        email: info.email,
+        api: info.api,
+        expiresAt: info.expiresAt,
+        valid: info.valid,
+        refreshHealth: info.refreshHealth,
+        quota,
+        dashboard: DASHBOARD_URL,
+      }
+      : {
+        loggedIn: false,
+        dashboard: DASHBOARD_URL,
+      };
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  if (!info) {
+    console.log('Not logged in. Run: voxflow login');
+    return;
+  }
+
+  console.log(`Email:   ${info.email}`);
+  console.log(`API:     ${info.api}`);
+  console.log(`Expires: ${info.expiresAt}`);
+  console.log(`Valid:   ${info.valid ? '\x1b[32myes\x1b[0m' : '\x1b[31mexpired\x1b[0m'}`);
+  // Surface refresh-token health so users notice a malformed/missing
+  // refresh_token *before* the access_token expires and forces a surprise
+  // browser login (the 2026-05-07 incident).
+  if (info.refreshHealth === 'ok') {
+    console.log(`Refresh: \x1b[32mhealthy\x1b[0m`);
+  } else if (info.refreshHealth === 'missing') {
+    console.log(`Refresh: \x1b[33mmissing — next token expiry will require browser login\x1b[0m`);
+  } else if (info.refreshHealth === 'malformed') {
+    console.log(`Refresh: \x1b[31mmalformed — run \x1b[36mvoxflow login\x1b[31m to recover cleanly\x1b[0m`);
+  }
+
+  if (quota) {
+    for (const line of formatQuotaLines(quota)) console.log(line);
+  }
+
+  if (!info.valid) {
+    console.log('\nToken expired. Run: voxflow login');
+  }
+
+  console.log(`\nDashboard: ${DASHBOARD_URL}`);
+  console.log('Run \x1b[36mvoxflow dashboard\x1b[0m to open in browser.');
+}
+
+async function handleDashboard() {
+  const url = DASHBOARD_URL;
+  console.log(`\nOpening dashboard: ${url}`);
+  try {
+    const open = (await import('open')).default;
+    const cp = await open(url);
+    if (cp && typeof cp.on === 'function') {
+      cp.on('error', () => {
+        console.log('\x1b[31mFailed to open browser. Visit manually:\x1b[0m');
+        console.log(`  ${url}`);
+      });
+    }
+  } catch {
+    console.log('\x1b[31mFailed to open browser. Visit manually:\x1b[0m');
+    console.log(`  ${url}`);
+  }
+}
+
+async function handleClone(args = []) {
+  const fs = require('fs');
+  const path = require('path');
+  const inputFile = parseFlag(args, '--input') || parseFlag(args, '-i');
+  const voiceName = parseFlag(args, '--name') || '';
+
+  // No file provided → open web UI
+  if (!inputFile) {
+    const url = VOICE_CLONE_URL;
+    console.log('\nNo --input file provided. Opening web interface for recording...');
+    console.log('Record or upload 30+ seconds of audio, then get a voice ID you can use anywhere.\n');
+    console.log(`Opening: ${url}`);
+    try {
+      const open = (await import('open')).default;
+      const cp = await open(url);
+      if (cp && typeof cp.on === 'function') {
+        cp.on('error', () => {
+          console.log('\x1b[31mFailed to open browser. Visit manually:\x1b[0m');
+          console.log(`  ${url}`);
+        });
+      }
+    } catch {
+      console.log('\x1b[31mFailed to open browser. Visit manually:\x1b[0m');
+      console.log(`  ${url}`);
+    }
+    console.log('\nOr provide a local audio file:');
+    console.log('  voxflow clone --input my-voice.wav --name "My Voice"');
+    return;
+  }
+
+  // File provided → upload and clone via API
+  const resolved = path.resolve(inputFile);
+  if (!fs.existsSync(resolved)) {
+    console.error(`Error: File not found: ${resolved}`);
+    process.exit(1);
+  }
+
+  const api = parseFlag(args, '--api') || API_BASE;
+  const explicitToken = parseFlag(args, '--token');
+  const { throwApiError, throwNetworkError } = require('../core/http');
+  const { startSpinner } = require('../core/spinner');
+
+  // Authenticate
+  const token = explicitToken || await getToken({ api });
+  const info = getTokenInfo();
+  if (info) {
+    console.log(`\x1b[32mLogged in as ${info.email}\x1b[0m`);
+  }
+
+  // Read file and convert to base64
+  const audioBuffer = fs.readFileSync(resolved);
+  const audioData = audioBuffer.toString('base64');
+  const fileSizeMB = (audioBuffer.length / 1024 / 1024).toFixed(1);
+
+  // Validate size (10MB limit)
+  if (audioBuffer.length > 10 * 1024 * 1024) {
+    console.error(`Error: File too large (${fileSizeMB}MB). Maximum is 10MB.`);
+    process.exit(1);
+  }
+
+  // Use filename as voice name if not provided
+  const name = voiceName || path.basename(resolved, path.extname(resolved));
+
+  console.log(`\nCloning voice from: ${path.basename(resolved)} (${fileSizeMB}MB)`);
+  console.log(`Voice name: ${name}`);
+
+  async function doClone(opts) {
+    const spinner = startSpinner('Cloning voice');
+    let status, data;
+    try {
+      ({ status, data } = await request(`${api}/api/voice/clone`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${opts.token}`,
+        },
+      }, {
+        audioData,
+        voiceName: name,
+      }));
+    } catch (err) {
+      spinner.stop('');
+      throwNetworkError(err, api);
+    }
+
+    spinner.stop('');
+
+    if (status === 401) {
+      // Let runWithRetry catch the token_expired ApiError and refresh.
+      throwApiError(401, data, 'voice clone');
+    }
+
+    if (status !== 200 || data?.code !== 'success') {
+      const msg = data?.message || `Clone failed (HTTP ${status})`;
+      console.error(`\x1b[31mError: ${msg}\x1b[0m`);
+      if (data?.code === 'clone_limit_exceeded') {
+        console.error('Tip: Delete unused clones at https://www.voxflow.studio/app#voice-clone');
+      }
+      process.exit(1);
+    }
+
+    const voiceId = data.voiceId || data.data?.voiceId || data.data?.voice_id || 'unknown';
+    console.log(`\n\x1b[32mVoice cloned successfully!\x1b[0m`);
+    console.log(`Voice ID: \x1b[36m${voiceId}\x1b[0m`);
+    console.log(`\nUse it in any command:`);
+    console.log(`  voxflow say "你好" --voice ${voiceId}`);
+    console.log(`  voxflow narrate --input doc.md --voice ${voiceId}`);
+    console.log(`  voxflow podcast "topic" --voice ${voiceId}`);
+  }
+
+  await runWithRetry(doClone, { token }, api, explicitToken);
+}
+
+// ─── Meta ───────────────────────────────────────────────────────────────────
+
+const meta = {
+  login: {
+    usage: '[--otp] [--print-url] [--paste <json>]',
+    description: 'Login via browser (default), terminal OTP, or non-interactive paste (for AI agents)',
+    options: [
+      '--otp                 Login via email + verification code in terminal (no browser)',
+      '--print-url           Print the login URL and exit (no listener) — for AI agents that hand the URL to a human',
+      '--paste <json|->     Accept the auth payload from a flag (or `-` to read stdin) — pairs with --print-url',
+    ],
+    examples: [
+      'voxflow login                                    # browser flow (interactive)',
+      'voxflow login --otp                              # terminal OTP (no browser)',
+      'voxflow login --print-url                        # AI agent: print URL, hand to user',
+      'voxflow login --paste \'{"access_token":"..."}\'   # AI agent: feed back the JSON the user copied',
+    ],
+  },
+  logout:   { usage: '', description: 'Clear cached token' },
+  status:   { usage: '[--json]', description: 'Show login status and token info', options: ['--json  Output machine-readable JSON (for scripts/CI)'] },
+  dashboard:{ usage: '', description: 'Open Web dashboard in browser' },
+  clone:    { usage: '[--input <file>] [--name <name>]', description: 'Clone your voice from an audio file, or open web UI to record', options: ['--input <file>  Audio file (wav/mp3, 30s+) to clone from', '--name <name>   Voice name (default: filename)'] },
+};
+
+module.exports = {
+  handleLogin,
+  handleLogout,
+  handleStatus,
+  handleDashboard,
+  handleClone,
+  meta,
+  _test: {
+    fetchQuota,
+    formatQuotaLines,
+    readAllStdin,
+  },
+};