pqm-cli 1.0.0

package/src/utils/http.js

@@ -0,0 +1,130 @@
+import https from 'https';
+import http from 'http';
+
+/**
+ * Make an HTTP/HTTPS request
+ * @param {Object} options - Request options
+ * @returns {Promise<Object>} Response object with data and status
+ */
+export function request(options) {
+  return new Promise((resolve, reject) => {
+    const {
+      url,
+      method = 'GET',
+      headers = {},
+      body = null,
+      timeout = 30000
+    } = options;
+
+    // Parse URL
+    const urlObj = new URL(url);
+    const isHttps = urlObj.protocol === 'https:';
+    const client = isHttps ? https : http;
+
+    const reqOptions = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (isHttps ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      method: method.toUpperCase(),
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers
+      },
+      timeout
+    };
+
+    const req = client.request(reqOptions, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        resolve({
+          status: res.statusCode,
+          headers: res.headers,
+          data: data
+        });
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(new Error(`HTTP request failed: ${err.message}`));
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    if (body) {
+      req.write(typeof body === 'string' ? body : JSON.stringify(body));
+    }
+
+    req.end();
+  });
+}
+
+/**
+ * Make a GET request
+ * @param {string} url - Request URL
+ * @param {Object} headers - Request headers
+ * @param {number} timeout - Timeout in milliseconds
+ * @returns {Promise<Object>} Parsed JSON response
+ */
+export async function get(url, headers = {}, timeout = 30000) {
+  const response = await request({ url, method: 'GET', headers, timeout });
+
+  if (response.status >= 400) {
+    throw new Error(`HTTP ${response.status}: ${response.data}`);
+  }
+
+  try {
+    return JSON.parse(response.data);
+  } catch {
+    return response.data;
+  }
+}
+
+/**
+ * Make a POST request
+ * @param {string} url - Request URL
+ * @param {Object} body - Request body
+ * @param {Object} headers - Request headers
+ * @param {number} timeout - Timeout in milliseconds
+ * @returns {Promise<Object>} Parsed JSON response
+ */
+export async function post(url, body = {}, headers = {}, timeout = 60000) {
+  const response = await request({
+    url,
+    method: 'POST',
+    body,
+    headers,
+    timeout
+  });
+
+  if (response.status >= 400) {
+    const errorData = response.data;
+    let errorMessage = `HTTP ${response.status}`;
+    try {
+      const parsed = JSON.parse(errorData);
+      errorMessage += `: ${parsed.message || parsed.error || JSON.stringify(parsed)}`;
+    } catch {
+      errorMessage += `: ${errorData}`;
+    }
+    throw new Error(errorMessage);
+  }
+
+  try {
+    return JSON.parse(response.data);
+  } catch {
+    return response.data;
+  }
+}
+
+export default {
+  request,
+  get,
+  post
+};

package/src/utils/logger.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+
+export const logger = {
+  info: (msg) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg) => console.log(chalk.green('✓'), msg),
+  warn: (msg) => console.log(chalk.yellow('⚠'), msg),
+  error: (msg) => console.log(chalk.red('✗'), msg),
+  watch: (file) => console.log(chalk.cyan('👁'), chalk.gray(file)),
+  build: (mode) => console.log(chalk.magenta('⚡'), `Building (${mode})...`),
+  debug: (msg) => {
+    if (process.env.PQM_DEBUG) {
+      console.log(chalk.gray('🔍'), chalk.gray(msg));
+    }
+  }
+};
+
+export function formatTimestamp() {
+  return new Date().toISOString().replace('T', ' ').slice(0, 19);
+}
+
+export function logWithTime(msg, type = 'info') {
+  const timestamp = formatTimestamp();
+  logger[type](`[${timestamp}] ${msg}`);
+}

package/src/utils/prompt.js

@@ -0,0 +1,132 @@
+import readline from 'readline';
+
+/**
+ * Create readline interface
+ * @returns {readline.Interface}
+ */
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Prompt user for input
+ * @param {string} question - Question to ask
+ * @param {string} defaultValue - Default value if user presses enter
+ * @returns {Promise<string>} User's answer
+ */
+export function promptUser(question, defaultValue = '') {
+  return new Promise((resolve) => {
+    const rl = createInterface();
+    const displayQuestion = defaultValue
+      ? `${question} (${defaultValue}): `
+      : `${question}: `;
+
+    rl.question(displayQuestion, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+/**
+ * Prompt user for password input (hidden)
+ * @param {string} question - Question to ask
+ * @returns {Promise<string>} User's password
+ */
+export function promptPassword(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface();
+    // Note: In a real terminal, we'd use mute mode for password
+    // For simplicity, we just use regular input
+    rl.question(`${question}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Prompt user to select from options
+ * @param {string} question - Question to ask
+ * @param {Array<Object|string>} options - Options to choose from
+ * @param {number} defaultIndex - Default selection index
+ * @returns {Promise<Object|string>} Selected option
+ */
+export async function select(question, options, defaultIndex = 0) {
+  console.log(`\n${question}`);
+  console.log('');
+
+  options.forEach((opt, index) => {
+    const label = typeof opt === 'string' ? opt : opt.label || opt.name;
+    const marker = index === defaultIndex ? '>' : ' ';
+    console.log(`  ${marker} ${index + 1}. ${label}`);
+  });
+
+  console.log('');
+
+  const answer = await promptUser('请选择 (输入序号)', String(defaultIndex + 1));
+  const index = parseInt(answer, 10) - 1;
+
+  if (isNaN(index) || index < 0 || index >= options.length) {
+    return options[defaultIndex];
+  }
+
+  return options[index];
+}
+
+/**
+ * Prompt user for confirmation
+ * @param {string} question - Question to ask
+ * @param {boolean} defaultValue - Default value
+ * @returns {Promise<boolean>} True if confirmed
+ */
+export async function confirm(question, defaultValue = false) {
+  const hint = defaultValue ? 'Y/n' : 'y/N';
+  const answer = await promptUser(`${question} (${hint})`, '');
+
+  if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+    return true;
+  }
+  if (answer.toLowerCase() === 'n' || answer.toLowerCase() === 'no') {
+    return false;
+  }
+
+  return defaultValue;
+}
+
+/**
+ * Prompt for multiple inputs
+ * @param {Array<Object>} prompts - Array of prompt configurations
+ * @returns {Promise<Object>} Object with answers
+ */
+export async function promptMultiple(prompts) {
+  const answers = {};
+
+  for (const prompt of prompts) {
+    const { name, question, defaultValue = '', type = 'text' } = prompt;
+
+    let answer;
+    if (type === 'password') {
+      answer = await promptPassword(question);
+    } else if (type === 'confirm') {
+      answer = await confirm(question, defaultValue);
+    } else {
+      answer = await promptUser(question, defaultValue);
+    }
+
+    answers[name] = answer;
+  }
+
+  return answers;
+}
+
+export default {
+  promptUser,
+  promptPassword,
+  select,
+  confirm,
+  promptMultiple
+};

package/src/utils/spinner.js

@@ -0,0 +1,134 @@
+import chalk from 'chalk';
+
+// Try to load ora, fall back to SimpleSpinner if not available
+let ora = null;
+try {
+  const oraModule = await import('ora');
+  ora = oraModule.default;
+} catch {
+  // ora not available, will use SimpleSpinner
+}
+
+// Simple spinner without ora dependency
+export class SimpleSpinner {
+  constructor(text = '') {
+    this.text = text;
+    this.interval = null;
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.frameIndex = 0;
+  }
+
+  start(text) {
+    this.text = text || this.text;
+    process.stdout.write('\x1B[?25l'); // Hide cursor
+    this.interval = setInterval(() => {
+      process.stdout.write(`\r${chalk.cyan(this.frames[this.frameIndex])} ${this.text}`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80);
+    return this;
+  }
+
+  stop(clearLine = true) {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (clearLine) {
+      process.stdout.write('\r\x1B[K');
+    }
+    process.stdout.write('\x1B[?25h'); // Show cursor
+    return this;
+  }
+
+  succeed(text) {
+    this.stop(false);
+    process.stdout.write(`\r${chalk.green('✓')} ${text || this.text}\n`);
+    return this;
+  }
+
+  fail(text) {
+    this.stop(false);
+    process.stdout.write(`\r${chalk.red('✗')} ${text || this.text}\n`);
+    return this;
+  }
+
+  warn(text) {
+    this.stop(false);
+    process.stdout.write(`\r${chalk.yellow('!')} ${text || this.text}\n`);
+    return this;
+  }
+
+  info(text) {
+    this.stop(false);
+    process.stdout.write(`\r${chalk.blue('i')} ${text || this.text}\n`);
+    return this;
+  }
+
+  update(text) {
+    this.text = text;
+    return this;
+  }
+}
+
+// Ora-based spinner (used when ora is available)
+class OraSpinner {
+  constructor(text = '') {
+    this.spinner = null;
+    this.text = text;
+  }
+
+  start(text) {
+    this.spinner = ora({
+      text: text || this.text,
+      spinner: 'dots'
+    }).start();
+    return this;
+  }
+
+  stop() {
+    if (this.spinner) {
+      this.spinner.stop();
+    }
+    return this;
+  }
+
+  succeed(text) {
+    if (this.spinner) {
+      this.spinner.succeed(chalk.green(text || this.text));
+    }
+    return this;
+  }
+
+  fail(text) {
+    if (this.spinner) {
+      this.spinner.fail(chalk.red(text || this.text));
+    }
+    return this;
+  }
+
+  warn(text) {
+    if (this.spinner) {
+      this.spinner.warn(chalk.yellow(text || this.text));
+    }
+    return this;
+  }
+
+  info(text) {
+    if (this.spinner) {
+      this.spinner.info(chalk.blue(text || this.text));
+    }
+    return this;
+  }
+
+  update(text) {
+    if (this.spinner) {
+      this.spinner.text = text;
+    }
+    return this;
+  }
+}
+
+// Export appropriate Spinner based on ora availability
+export const Spinner = ora ? OraSpinner : SimpleSpinner;
+
+export default Spinner;