voxflow 1.15.0 → 1.15.2

package/lib/commands/image.js

@@ -0,0 +1,207 @@
+/**
+ * VoxFlow CLI — Image command
+ *
+ * Text-to-image via Tencent Hunyuan (TextToImageLite). Synchronous call,
+ * returns base64 PNG + COS URL. Writes the PNG locally and prints the URL.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { request, throwApiError, throwNetworkError, ApiError } = require('../core/http');
+const { startSpinner } = require('../core/spinner');
+
+const VALID_RESOLUTIONS = [
+  '768:768', '768:1024', '1024:768',
+  '1024:1024', '720:1280', '1280:720',
+  '768:1280', '1280:768', '1080:1920', '1920:1080',
+];
+
+/**
+ * Generate an image via the Hunyuan API.
+ *
+ * @param {object} opts
+ * @param {string} opts.token       - JWT token
+ * @param {string} opts.api         - API base URL
+ * @param {string} opts.prompt      - Image description
+ * @param {string} [opts.resolution] - e.g. '1024:1024' (default)
+ * @param {string} [opts.output]    - Output PNG path
+ * @returns {Promise<{outputPath: string, imageUrl: string|null, requestId: string, quota: object}>}
+ */
+async function generateHunyuanImage(opts) {
+  let isExiting = false;
+  const sigintHandler = () => {
+    if (isExiting) return;
+    isExiting = true;
+    console.log('\n\nImage generation cancelled.');
+    process.exit(130);
+  };
+  process.on('SIGINT', sigintHandler);
+
+  try {
+    return await _generate(opts);
+  } finally {
+    process.removeListener('SIGINT', sigintHandler);
+  }
+}
+
+async function _generate(opts) {
+  const prompt = opts.prompt;
+  if (!prompt || prompt.trim().length === 0) {
+    throw new Error('No prompt provided. Usage: voxflow image "your prompt here"');
+  }
+  if (prompt.length > 1000) {
+    throw new Error('Prompt too long (max 1000 characters)');
+  }
+
+  const resolution = opts.resolution || '1024:1024';
+  const api = opts.api;
+  const token = opts.token;
+
+  // Default output path
+  let outputPath = opts.output;
+  if (!outputPath) {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    outputPath = path.resolve(`hunyuan-${ts}.png`);
+  }
+
+  console.log('\n=== VoxFlow Image (Hunyuan) ===');
+  console.log(`Prompt:     ${prompt.length > 60 ? prompt.slice(0, 57) + '...' : prompt}`);
+  console.log(`Resolution: ${resolution}`);
+  console.log(`Output:     ${outputPath}`);
+
+  const spinner = startSpinner('\n[1/1] Generating image (10-30s)...');
+
+  let status, data;
+  try {
+    ({ status, data } = await request(`${api}/api/hunyuan/text-to-image`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      timeoutMs: 180_000,
+    }, {
+      prompt: prompt.trim(),
+      resolution,
+      logoAdd: 0,
+      rspImgType: 'base64',
+    }));
+  } catch (err) {
+    spinner.stop('FAIL');
+    throwNetworkError(err, api);
+  }
+
+  if (status !== 200 || data.code !== 'success') {
+    spinner.stop('FAIL');
+    throwApiError(status, data, 'Image generation');
+  }
+
+  if (!data.image) {
+    spinner.stop('FAIL');
+    throw new Error('API returned no image data');
+  }
+
+  const imgBuffer = Buffer.from(data.image, 'base64');
+  spinner.stop('OK');
+
+  const outDir = path.dirname(outputPath);
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(outputPath, imgBuffer);
+
+  console.log('\n=== Done ===');
+  console.log(`Output:    ${outputPath} (${(imgBuffer.length / 1024).toFixed(1)} KB)`);
+  if (data.imageUrl) console.log(`COS URL:   ${data.imageUrl}`);
+  console.log(`RequestId: ${data.requestId || '(none)'}`);
+  if (data.quota) {
+    console.log(`Quota:     ${data.quota.used ?? '?'}/${data.quota.daily ?? '?'}, remaining ${data.quota.remaining ?? '?'}`);
+  }
+
+  return {
+    outputPath,
+    imageUrl: data.imageUrl || null,
+    requestId: data.requestId,
+    quota: data.quota,
+  };
+}
+
+// ─── CLI Handler ────────────────────────────────────────────────────────────
+
+async function handle(args) {
+  const { parseFlag, runWithRetry } = require('../core/args');
+  const { getToken, getTokenInfo } = require('../core/auth');
+  const { API_BASE } = require('../core/config');
+
+  const api = parseFlag(args, '--api') || API_BASE;
+  const explicitToken = parseFlag(args, '--token');
+
+  // Prompt: --prompt flag or first positional arg
+  let prompt = parseFlag(args, '--prompt');
+  if (!prompt) {
+    const valuedFlags = new Set(['--prompt', '--resolution', '--output', '-o', '--token', '--api']);
+    for (let i = 0; i < args.length; i++) {
+      if (args[i].startsWith('-')) {
+        if (valuedFlags.has(args[i])) i++;
+        continue;
+      }
+      prompt = args[i];
+      break;
+    }
+  }
+
+  if (!prompt) {
+    console.error('Error: No prompt provided. Usage: voxflow image "your prompt here"');
+    process.exit(1);
+  }
+
+  const resolution = parseFlag(args, '--resolution');
+  if (resolution && !VALID_RESOLUTIONS.includes(resolution)) {
+    console.error(`Error: --resolution must be one of: ${VALID_RESOLUTIONS.join(', ')} (got: "${resolution}")`);
+    process.exit(1);
+  }
+
+  const output = parseFlag(args, '--output', '-o');
+  if (output && !output.toLowerCase().endsWith('.png')) {
+    console.error('Error: --output path must end with .png');
+    process.exit(1);
+  }
+
+  let token;
+  if (explicitToken) {
+    token = explicitToken;
+  } else {
+    token = await getToken({ api });
+    const info = getTokenInfo();
+    if (info) {
+      console.log(`\x1b[32mLogged in as ${info.email}\x1b[0m`);
+    }
+  }
+
+  const opts = {
+    token, api, prompt,
+    resolution: resolution || undefined,
+    output,
+  };
+
+  await runWithRetry(generateHunyuanImage, opts, api, explicitToken);
+}
+
+const meta = {
+  image: {
+    usage: '<prompt>',
+    description: 'Generate an image from text via Hunyuan (text-to-image)',
+    options: [
+      '<prompt>             Image description (positional arg or --prompt)',
+      '--prompt <text>      Image description (alternative to positional)',
+      '--resolution <W:H>   Resolution, colon-separated (default: 1024:1024)',
+      '                     Options: 768:768, 1024:1024, 1024:768, 768:1024,',
+      '                              1280:720, 720:1280, 1920:1080, 1080:1920',
+      '-o, --output <path>  Output PNG path (default: ./hunyuan-<timestamp>.png)',
+    ],
+    examples: [
+      'voxflow image "雨中, 竹林, 小路, 中国风"',
+      'voxflow image "A calm ocean at sunset" --resolution 1920:1080 -o sunset.png',
+    ],
+  },
+};
+
+module.exports = { generateHunyuanImage, handle, meta, ApiError };

package/lib/commands/mcp-key.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * VoxFlow CLI — `voxflow mcp-key` subcommand
+ *
+ *   create [--name <text>] [--expires <duration>]
+ *   list
+ *   revoke <id>
+ *
+ * Manages long-lived MCP API keys (PAT, `mk_<32 chars>`) for wrapper-class
+ * MCP clients that bypass mcporter's OAuth provider — e.g. Box, which
+ * substitutes env vars into static config headers. Created key is shown
+ * ONCE; only the prefix is retrievable later.
+ */
+
+const { getToken } = require('../core/auth');
+const { request, ApiError } = require('../core/http');
+const { API_BASE } = require('../core/config');
+const { parseFlag, runWithRetry } = require('../core/args');
+
+function parseDurationToISO(s) {
+    if (!s) return null;
+    // Accept formats: "30d", "90d", "365d", "1y", or an ISO 8601 timestamp.
+    const m = String(s).match(/^(\d+)\s*(d|day|days|y|year|years)$/i);
+    if (m) {
+        const n = parseInt(m[1], 10);
+        const unitDays = /^y/i.test(m[2]) ? 365 : 1;
+        return new Date(Date.now() + n * unitDays * 86_400_000).toISOString();
+    }
+    const ms = Date.parse(s);
+    if (!Number.isFinite(ms)) {
+        throw new Error(`Invalid --expires: ${s} (use "30d", "1y", or ISO timestamp)`);
+    }
+    if (ms <= Date.now()) {
+        throw new Error('--expires must be a future date');
+    }
+    return new Date(ms).toISOString();
+}
+
+async function callApi(token, method, path, body) {
+    const url = new URL(path, API_BASE).href;
+    const res = await request(url, {
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`
+        }
+    }, body);
+    if (res.status >= 400) {
+        const { throwApiError } = require('../core/http');
+        throwApiError(res.status, res.data, `${method} ${path}`, res.headers);
+    }
+    return res.data;
+}
+
+async function cmdCreate(args, opts) {
+    const name = parseFlag(args, '--name') || `voxflow-cli-${new Date().toISOString().slice(0, 10)}`;
+    const expiresFlag = parseFlag(args, '--expires');
+    const expiresAt = expiresFlag ? parseDurationToISO(expiresFlag) : null;
+
+    const result = await callApi(opts.token, 'POST', '/api/mcp/api-keys', { name, expiresAt });
+    const key = result.data;
+
+    process.stdout.write(`\nMCP API Key created\n`);
+    process.stdout.write(`  Name:       ${key.name}\n`);
+    process.stdout.write(`  Created:    ${key.createdAt}\n`);
+    if (key.expiresAt) {
+        process.stdout.write(`  Expires:    ${key.expiresAt}\n`);
+    } else {
+        process.stdout.write(`  Expires:    never\n`);
+    }
+    process.stdout.write(`\n  Key (shown only once — copy now):\n\n    ${key.rawKey}\n\n`);
+    process.stdout.write(`  Use it in mcporter.json or any MCP client config:\n`);
+    process.stdout.write(`    "Authorization": "Bearer ${key.rawKey}"\n\n`);
+    process.stdout.write(`  Or via env var (recommended):\n`);
+    process.stdout.write(`    export VOXFLOW_TOKEN="${key.rawKey}"\n`);
+    process.stdout.write(`    "Authorization": "Bearer \${VOXFLOW_TOKEN}"\n\n`);
+}
+
+async function cmdList(_args, opts) {
+    const result = await callApi(opts.token, 'GET', '/api/mcp/api-keys');
+    const keys = result.data || [];
+    if (keys.length === 0) {
+        process.stdout.write(`\nNo MCP API keys yet. Create one: voxflow mcp-key create --name "..."\n\n`);
+        return;
+    }
+    process.stdout.write(`\n${keys.length} MCP API key${keys.length === 1 ? '' : 's'}:\n\n`);
+    for (const k of keys) {
+        const status = k.revokedAt
+            ? `revoked ${k.revokedAt.slice(0, 10)}`
+            : (k.expiresAt && Date.parse(k.expiresAt) < Date.now())
+                ? `expired ${k.expiresAt.slice(0, 10)}`
+                : 'active';
+        const lastUsed = k.lastUsedAt
+            ? new Date(k.lastUsedAt).toISOString().slice(0, 10)
+            : 'never';
+        process.stdout.write(`  ${k.keyPrefix}  ${k.name}\n`);
+        process.stdout.write(`    id: ${k.id}  status: ${status}  last_used: ${lastUsed}\n`);
+        if (k.expiresAt && !k.revokedAt) {
+            process.stdout.write(`    expires: ${k.expiresAt}\n`);
+        }
+        process.stdout.write(`\n`);
+    }
+}
+
+async function cmdRevoke(args, opts) {
+    const id = args.find(a => !a.startsWith('--') && a !== 'revoke');
+    if (!id) {
+        process.stderr.write('Usage: voxflow mcp-key revoke <id>\n');
+        process.exit(1);
+    }
+    await callApi(opts.token, 'DELETE', `/api/mcp/api-keys/${encodeURIComponent(id)}`);
+    process.stdout.write(`\nKey ${id} revoked.\n\n`);
+}
+
+async function handle(args) {
+    // Resolve subcommand: positional after the parser strips "mcp-key".
+    // Layout received here is the args AFTER "mcp-key" — first non-flag is
+    // the subcommand. Default to "list" so `voxflow mcp-key` is informative.
+    const sub = args.find(a => !a.startsWith('--')) || 'list';
+    const subArgs = args.slice(args.indexOf(sub) + 1);
+
+    const apiOverride = parseFlag(args, '--api');
+    const tokenOverride = parseFlag(args, '--token');
+    const api = apiOverride || API_BASE;
+    const token = tokenOverride || await getToken({ api });
+
+    const opts = { token };
+    const dispatch = { create: cmdCreate, list: cmdList, revoke: cmdRevoke };
+    const fn = dispatch[sub];
+    if (!fn) {
+        process.stderr.write(`Unknown mcp-key subcommand: ${sub}\nAvailable: create | list | revoke\n`);
+        process.exit(1);
+    }
+
+    try {
+        await runWithRetry((o) => fn(subArgs, o), opts, api, !!tokenOverride);
+    } catch (err) {
+        if (err instanceof ApiError) {
+            process.stderr.write(`\nError: ${err.message}\n\n`);
+            process.exit(1);
+        }
+        throw err;
+    }
+}
+
+const meta = {
+    'mcp-key': {
+        usage: '<create | list | revoke> [options]',
+        description: 'Manage long-lived MCP API keys (PAT, mk_xxx) for wrapper clients (Box, etc.)',
+        options: [
+            'create --name <text>      Create a new key (shown ONCE)',
+            '       --expires <dur>    Optional: 30d / 90d / 1y / ISO timestamp',
+            'list                      List your active and revoked keys',
+            'revoke <id>               Revoke a key by id (from `mcp-key list`)'
+        ],
+        examples: [
+            'voxflow mcp-key create --name "Box on MacBook"',
+            'voxflow mcp-key create --name "CI runner" --expires 90d',
+            'voxflow mcp-key list',
+            'voxflow mcp-key revoke 11ed1234-5678-...'
+        ]
+    }
+};
+
+module.exports = { handle, meta, parseDurationToISO };