@aweray/hsk-cli 0.2.2

package/lib/fileHosting.js

@@ -0,0 +1,257 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const fetch = require('node-fetch');
+const FormData = require('form-data');
+const { spawn } = require('child_process');
+const version = require('./version');
+
+const DEFAULT_CONFIG = {
+  ticketHost: 'onion-forward-api.oraybeta.com',
+  ticketPort: 443,
+  ticketScheme: 'https',
+  uploadHost: 'onion-fw-test2.oraybeta.com',
+  uploadPort: 8010,
+  uploadScheme: 'https',
+};
+
+const HEADERS_BASE = {
+  'User-Agent': `HSK-CLI/${version}`,
+  Accept: '*/*',
+  Connection: 'keep-alive',
+};
+
+function getTicketApiUrl() {
+  if (process.env.HSK_FILE_HOSTING_API) {
+    return process.env.HSK_FILE_HOSTING_API.replace(/\/+$/, '');
+  }
+  const host = process.env.HSK_FILE_HOSTING_TICKET_HOST || DEFAULT_CONFIG.ticketHost;
+  const port = process.env.HSK_FILE_HOSTING_TICKET_PORT || DEFAULT_CONFIG.ticketPort;
+  const scheme = process.env.HSK_FILE_HOSTING_TICKET_SCHEME || DEFAULT_CONFIG.ticketScheme;
+  return `${scheme}://${host}:${port}/public/file-hosting`;
+}
+
+function getUploadBaseUrl() {
+  const host = process.env.HSK_FILE_HOSTING_UPLOAD_HOST || DEFAULT_CONFIG.uploadHost;
+  const port = process.env.HSK_FILE_HOSTING_UPLOAD_PORT || DEFAULT_CONFIG.uploadPort;
+  const scheme = process.env.HSK_FILE_HOSTING_UPLOAD_SCHEME || DEFAULT_CONFIG.uploadScheme;
+  return `${scheme}://${host}:${port}`;
+}
+
+const TICKET_API = getTicketApiUrl();
+
+/**
+ * 检查文件托管 API 配置
+ */
+function checkApiConfig() {
+  // 可通过环境变量覆盖 ticket / upload 服务地址，见 getTicketApiUrl / getUploadBaseUrl
+}
+
+/**
+ * 计算文件 SHA-256 hash
+ */
+function sha256File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * 获取文件托管 ticket（创建不传 resourceId，更新时传 resourceId）
+ */
+async function getFileHostingTicket(fileHash, resourceId = null) {
+  const payload = { file_hash: fileHash };
+  if (resourceId) {
+    payload.resource_id = resourceId;
+  }
+
+  const res = await fetch(TICKET_API, {
+    method: 'POST',
+    headers: { ...HEADERS_BASE, 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`获取 ticket 失败: HTTP ${res.status} - ${text.slice(0, 500)}`);
+  }
+
+  const json = await res.json();
+  const data = json.data;
+
+  if (!data || !data.ticket) {
+    throw new Error(`获取 ticket 响应格式异常: ${JSON.stringify(json)}`);
+  }
+
+  return data;
+}
+
+/**
+ * 上传/更新资源文件
+ * @param {string} token - Bearer ticket
+ * @param {string} filePath - 本地文件路径
+ * @param {{ update?: boolean, uploadUrl?: string }} options
+ */
+async function uploadFile(token, filePath, options = {}) {
+  const { update = false, uploadUrl } = options;
+  const fileName = path.basename(filePath);
+  const form = new FormData();
+  form.append('file', fs.createReadStream(filePath), { filename: fileName });
+
+  const url = uploadUrl || `${getUploadBaseUrl()}${update ? '/resource/update' : '/upload'}`;
+  const method = update ? 'PUT' : 'POST';
+
+  const res = await fetch(url, {
+    method,
+    headers: {
+      ...HEADERS_BASE,
+      Authorization: `Bearer ${token}`,
+      ...form.getHeaders(),
+    },
+    body: form,
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`文件${update ? '更新' : '上传'}失败: HTTP ${res.status} - ${text.slice(0, 500)}`);
+  }
+
+  return res.json();
+}
+
+function resolveResourceId(ticketData, uploadResult, resourceIdInput) {
+  let resourceId = ticketData.resource_id || resourceIdInput || null;
+  const resultData = uploadResult && uploadResult.data;
+
+  if (resultData && typeof resultData === 'object' && resultData.resource_id) {
+    resourceId = resultData.resource_id;
+  }
+
+  if (!resourceId && ticketData.public_url) {
+    const parts = ticketData.public_url.replace(/\/+$/, '').split('/');
+    if (parts.length) {
+      resourceId = parts[parts.length - 1];
+    }
+  }
+
+  return resourceId;
+}
+
+/**
+ * 完整文件托管流程（创建或更新）
+ * @param {string} filePath
+ * @param {{ resourceId?: string }} options
+ */
+async function host(filePath, options = {}) {
+  checkApiConfig();
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`文件不存在: ${filePath}`);
+  }
+  if (fs.statSync(filePath).isDirectory()) {
+    throw new Error(
+      `路径是目录而非文件: ${filePath}\n` +
+      `请使用 \`hsk-cli deploy\` 命令上传目录，或手动打包后上传。`
+    );
+  }
+  if (!fs.statSync(filePath).isFile()) {
+    throw new Error(`路径不是文件: ${filePath}`);
+  }
+
+  const fileName = path.basename(filePath);
+  const resourceIdInput = options.resourceId || null;
+  const isUpdate = Boolean(resourceIdInput);
+
+  if (process.env.HSK_FILE_HOSTING_DIRECT) {
+    const form = new FormData();
+    form.append('file', fs.createReadStream(filePath), { filename: fileName });
+
+    const res = await fetch(TICKET_API, {
+      method: 'POST',
+      headers: { ...form.getHeaders() },
+      body: form,
+    });
+
+    if (!res.ok) {
+      throw new Error(`文件上传失败: HTTP ${res.status} - ${res.statusText}`);
+    }
+
+    const json = await res.json();
+    const baseUrl = TICKET_API.replace(/\/public\/file-hosting$/, '');
+    const publicUrl = `${baseUrl}/${fileName}`;
+
+    return {
+      success: true,
+      mode: 'direct',
+      publicUrl,
+      fileName,
+      filePath,
+      serverResponse: json,
+    };
+  }
+
+  const fileHash = await sha256File(filePath);
+  const ticket = await getFileHostingTicket(fileHash, resourceIdInput);
+
+  const useLegacyUpload = Boolean(ticket.server_address);
+  let uploadResult;
+  let uploadError;
+
+  try {
+    if (useLegacyUpload) {
+      uploadResult = await uploadFile(ticket.ticket, filePath, {
+        uploadUrl: ticket.server_address,
+        update: isUpdate,
+      });
+    } else {
+      uploadResult = await uploadFile(ticket.ticket, filePath, { update: isUpdate });
+    }
+  } catch (err) {
+    uploadError = err.message;
+  }
+
+  const resourceId = resolveResourceId(ticket, uploadResult, resourceIdInput);
+
+  return {
+    success: true,
+    mode: isUpdate ? 'update' : 'create',
+    publicUrl: ticket.public_url,
+    verifyCode: ticket.verify_code,
+    resourceId,
+    uploadHost: useLegacyUpload ? ticket.server_address : getUploadBaseUrl(),
+    fileName,
+    fileHash,
+    filePath,
+    uploadResponse: uploadResult,
+    error: uploadError,
+  };
+}
+
+/**
+ * 打开浏览器认领页面
+ */
+function openClaimUrl(url) {
+  return new Promise((resolve) => {
+    const platform = process.platform;
+    const command = platform === 'win32' ? 'start' : platform === 'darwin' ? 'open' : 'xdg-open';
+    const proc = spawn(command, [url], { stdio: 'ignore', detached: true, shell: platform === 'win32' });
+    proc.on('error', () => { /* ignore */ });
+    proc.unref();
+    resolve();
+  });
+}
+
+module.exports = {
+  TICKET_API,
+  getTicketApiUrl,
+  getUploadBaseUrl,
+  sha256File,
+  getFileHostingTicket,
+  uploadFile,
+  host,
+  openClaimUrl,
+};

package/lib/format.js

@@ -0,0 +1,116 @@
+const chalk = require('chalk');
+
+/**
+ * 格式化输出工具
+ * 支持 json / pretty / table / ndjson 格式
+ */
+
+function outputFormat(data, format) {
+  switch (format) {
+    case 'json':
+      return JSON.stringify(data, null, 2);
+
+    case 'ndjson':
+      return JSON.stringify(data);
+
+    case 'csv':
+      // 简单 CSV 实现（仅支持平铺对象）
+      if (typeof data === 'object' && data !== null && !Array.isArray(data)) {
+        const keys = Object.keys(data);
+        const header = keys.join(',');
+        const values = keys.map(k => {
+          const v = data[k];
+          if (typeof v === 'string') return `"${v.replace(/"/g, '""')}"`;
+          return String(v);
+        }).join(',');
+        return `${header}\n${values}`;
+      }
+      return JSON.stringify(data);
+
+    case 'table':
+      if (typeof data === 'object' && data !== null && !Array.isArray(data)) {
+        const rows = Object.entries(data).map(([k, v]) => {
+          const val = typeof v === 'object' ? JSON.stringify(v) : String(v);
+          return `${chalk.gray(k.padEnd(16))} │ ${val}`;
+        });
+        return rows.join('\n');
+      }
+      return JSON.stringify(data, null, 2);
+
+    case 'pretty':
+    default:
+      return formatPretty(data);
+  }
+}
+
+function formatPretty(data) {
+  // 根据数据类型返回人类友好的格式化文本
+  if (data.success === true && data.publicUrl) {
+    if (data.fileName) {
+      // 文件托管结果
+      return [
+        '\n' + chalk.green('✅ 文件托管已创建！') + '\n',
+        chalk.gray('📁 文件：') + data.fileName,
+        chalk.gray('🔍 Hash：') + data.fileHash,
+        chalk.cyan('🔗 公网访问地址：') + chalk.underline.bold(data.publicUrl),
+        data.error ? chalk.red('⚠️  上传异常：') + data.error : '',
+        '\n' + chalk.yellow('📋 下一步：'),
+        '   1. 在浏览器中打开上方公网地址',
+        '   2. 点击页面「确认认领」按钮完成绑定',
+        '   3. 认领后文件将绑定到你的账户\n',
+      ].filter(Boolean).join('\n');
+    } else {
+      // 内网穿透结果
+      const lines = [
+        '\n' + chalk.green('✅ 内网穿透已建立！') + '\n',
+        chalk.cyan('🔗 公网访问地址：') + chalk.underline.bold(data.publicUrl),
+        chalk.gray('📌 本地目标：') + `http://${data.ip}:${data.port}`,
+      ];
+      if (data.pid) {
+        lines.push(chalk.gray('🔧 进程 PID：') + data.pid);
+      }
+      if (data.detached) {
+        lines.push(chalk.gray('📂 日志文件：') + data.logFile);
+      }
+      lines.push(
+        '\n' + chalk.yellow('📋 下一步：'),
+        '   1. 在浏览器中打开上方公网地址',
+        '   2. 按页面提示完成激活认领',
+        '   3. 激活后隧道将绑定到你的账户'
+      );
+      if (!data.detached) {
+        lines.push(
+          '\n' + chalk.gray('⏹️  按 Ctrl+C 停止隧道')
+        );
+      }
+      return lines.join('\n');
+    }
+  }
+
+  // 后台模式无 URL（还未捕获到）
+  if (data.success === true && data.detached) {
+    return [
+      '\n' + chalk.green('✅ 后台隧道已启动！') + '\n',
+      chalk.gray('📌 本地目标：') + `http://${data.ip}:${data.port}`,
+      chalk.gray('🔧 进程 PID：') + data.pid,
+      chalk.gray('📂 日志文件：') + data.logFile,
+      '\n' + chalk.yellow('📋 提示：'),
+      '   使用 `hsk-cli tunnel list` 查看后台隧道',
+      '   使用 `hsk-cli tunnel stop --pid ' + data.pid + '` 停止该隧道\n',
+    ].join('\n');
+  }
+
+  if (data.success === false) {
+    return chalk.red('❌ 失败：') + (data.error || '未知错误');
+  }
+
+  // 默认回退到 json
+  return JSON.stringify(data, null, 2);
+}
+
+function dryRunInfo(command, details) {
+  return chalk.yellow('[DRY-RUN] ') + chalk.gray('将执行: ') + chalk.cyan(command) + '\n' +
+    Object.entries(details).map(([k, v]) => `  ${chalk.gray(k)}: ${v}`).join('\n');
+}
+
+module.exports = { outputFormat, formatPretty, dryRunInfo };

package/lib/pack.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+/**
+ * 将目录打包为 zip
+ * 跨平台实现：
+ * - Windows: PowerShell Compress-Archive
+ * - macOS/Linux: zip 命令
+ */
+function packDir(sourceDir, outputFile) {
+  return new Promise((resolve, reject) => {
+    const absSource = path.resolve(sourceDir);
+    const absOutput = path.resolve(outputFile);
+
+    if (!fs.existsSync(absSource)) {
+      return reject(new Error(`打包目录不存在: ${absSource}`));
+    }
+    if (!fs.statSync(absSource).isDirectory()) {
+      return reject(new Error(`路径不是目录: ${absSource}`));
+    }
+
+    let proc;
+    if (process.platform === 'win32') {
+      // Windows: PowerShell Compress-Archive
+      // 需要把目录内容单独列出，避免 zip 包含多余的父目录
+      const items = fs.readdirSync(absSource).map(item => path.join(absSource, item));
+      if (items.length === 0) {
+        return reject(new Error(`目录为空，无法打包: ${absSource}`));
+      }
+      const itemsStr = items.map(i => `"${i}"`).join(',');
+      proc = spawn('powershell', [
+        '-Command',
+        `Compress-Archive -Path ${itemsStr} -DestinationPath "${absOutput}" -Force`
+      ], { stdio: 'inherit' });
+    } else {
+      // macOS/Linux: zip -r output.zip .
+      proc = spawn('zip', ['-r', absOutput, '.'], {
+        cwd: absSource,
+        stdio: 'inherit'
+      });
+    }
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        const stats = fs.statSync(absOutput);
+        resolve({ path: absOutput, size: stats.size });
+      } else {
+        reject(new Error(`打包失败，退出码: ${code}`));
+      }
+    });
+
+    proc.on('error', (err) => {
+      reject(new Error(`打包执行失败: ${err.message}`));
+    });
+  });
+}
+
+/**
+ * 删除打包产物
+ */
+function cleanupPack(packPath) {
+  if (fs.existsSync(packPath)) {
+    fs.unlinkSync(packPath);
+  }
+}
+
+module.exports = { packDir, cleanupPack };

package/lib/pidManager.js

@@ -0,0 +1,142 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PID_DIR = path.join(os.homedir(), '.hsk', 'pids');
+const LOG_DIR = path.join(os.homedir(), '.hsk', 'logs');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function getPidFilePath(type, meta) {
+  ensureDir(PID_DIR);
+  const key = `${type}-${meta.ip || '0'}-${meta.port || '0'}.json`;
+  return path.join(PID_DIR, key);
+}
+
+function getLogFilePath(type, meta) {
+  ensureDir(LOG_DIR);
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const key = `${type}-${meta.ip || '0'}-${meta.port || '0'}-${timestamp}.log`;
+  return path.join(LOG_DIR, key);
+}
+
+function savePid(type, meta, pid) {
+  const pidFile = getPidFilePath(type, meta);
+  const logFile = getLogFilePath(type, meta);
+  const record = {
+    pid,
+    type,
+    meta,
+    createdAt: new Date().toISOString(),
+    logFile
+  };
+  fs.writeFileSync(pidFile, JSON.stringify(record, null, 2));
+  return record;
+}
+
+function listPids() {
+  ensureDir(PID_DIR);
+  const files = fs.readdirSync(PID_DIR);
+  const records = [];
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    const filePath = path.join(PID_DIR, file);
+    try {
+      const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      // 检查进程是否还在运行
+      const isRunning = isPidRunning(record.pid);
+      records.push({ ...record, isRunning, pidFile: filePath });
+    } catch (e) {
+      // 忽略损坏的 PID 文件
+    }
+  }
+  return records;
+}
+
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function removePidRecord(pid) {
+  const records = listPids();
+  for (const record of records) {
+    if (record.pid === pid) {
+      try {
+        fs.unlinkSync(record.pidFile);
+      } catch (e) {
+        // 忽略删除失败
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+function stopPid(pid) {
+  try {
+    process.kill(pid, 'SIGTERM');
+    // 等待一段时间后强制终止
+    setTimeout(() => {
+      try {
+        process.kill(pid, 'SIGKILL');
+      } catch (e) {
+        // 可能已经退出
+      }
+    }, 3000);
+    removePidRecord(pid);
+    return true;
+  } catch (e) {
+    removePidRecord(pid);
+    return false;
+  }
+}
+
+function stopAll() {
+  const records = listPids();
+  let count = 0;
+  for (const record of records) {
+    if (record.isRunning) {
+      stopPid(record.pid);
+      count++;
+    } else {
+      removePidRecord(record.pid);
+    }
+  }
+  return count;
+}
+
+function cleanupDeadPids() {
+  const records = listPids();
+  let count = 0;
+  for (const record of records) {
+    if (!record.isRunning) {
+      try {
+        fs.unlinkSync(record.pidFile);
+        count++;
+      } catch (e) {
+        // 忽略
+      }
+    }
+  }
+  return count;
+}
+
+module.exports = {
+  savePid,
+  listPids,
+  isPidRunning,
+  stopPid,
+  stopAll,
+  removePidRecord,
+  cleanupDeadPids,
+  getLogFilePath
+};

package/lib/platform.js

@@ -0,0 +1,64 @@
+const os = require('os');
+
+// 将 Node.js 平台标识符映射为二进制命名中的标识符
+const PLATFORM_MAP = {
+  'win32': 'windows',
+  'darwin': 'darwin',
+  'linux': 'linux'
+};
+
+const ARCH_MAP = {
+  'x64': 'amd64',
+  'arm64': 'arm64'
+};
+
+function detect() {
+  const nodePlatform = os.platform();
+  const nodeArch = os.arch();
+
+  const platform = PLATFORM_MAP[nodePlatform];
+  const arch = ARCH_MAP[nodeArch];
+
+  if (!platform || !arch) {
+    throw new Error(`不支持的平台: ${nodePlatform}-${nodeArch}。仅支持 Windows/macOS/Linux x64 和 arm64。`);
+  }
+
+  const isWindows = platform === 'windows';
+  const platformKey = `${platform}-${arch}`;
+
+  return {
+    platform,       // 'windows' | 'darwin' | 'linux'
+    arch,           // 'amd64' | 'arm64'
+    nodePlatform,   // 'win32' | 'darwin' | 'linux'
+    nodeArch,       // 'x64' | 'arm64'
+    isWindows,
+    platformKey     // 'windows-amd64' | 'darwin-arm64' 等
+  };
+}
+
+function fromString(archOverride) {
+  const map = {
+    'win32':       { platform: 'windows', arch: 'amd64', nodePlatform: 'win32',  nodeArch: 'x64' },
+    'win64':       { platform: 'windows', arch: 'amd64', nodePlatform: 'win32',  nodeArch: 'x64' },
+    'windows':     { platform: 'windows', arch: 'amd64', nodePlatform: 'win32',  nodeArch: 'x64' },
+    'macos':       { platform: 'darwin',  arch: 'amd64', nodePlatform: 'darwin', nodeArch: 'x64' },
+    'macos-x64':   { platform: 'darwin',  arch: 'amd64', nodePlatform: 'darwin', nodeArch: 'x64' },
+    'macos-arm64': { platform: 'darwin',  arch: 'arm64', nodePlatform: 'darwin', nodeArch: 'arm64' },
+    'linux':       { platform: 'linux',   arch: 'amd64', nodePlatform: 'linux',  nodeArch: 'x64' },
+    'linux-x64':   { platform: 'linux',   arch: 'amd64', nodePlatform: 'linux',  nodeArch: 'x64' },
+    'linux-arm64': { platform: 'linux',   arch: 'arm64', nodePlatform: 'linux',  nodeArch: 'arm64' }
+  };
+
+  const info = map[archOverride];
+  if (!info) {
+    throw new Error(`未知的架构: ${archOverride}。可用: ${Object.keys(map).join(', ')}`);
+  }
+
+  return {
+    ...info,
+    isWindows: info.platform === 'windows',
+    platformKey: `${info.platform}-${info.arch}`
+  };
+}
+
+module.exports = { detect, fromString };

package/lib/resourceChecker.js

@@ -0,0 +1,59 @@
+const { spawn } = require('child_process');
+const fetch = require('node-fetch');
+
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    if (process.platform === 'win32') {
+      const result = require('child_process').spawnSync('tasklist', ['/FI', `PID eq ${pid}`], { encoding: 'utf8' });
+      return result.stdout.includes(String(pid));
+    } else {
+      process.kill(pid, 0);
+      return true;
+    }
+  } catch (e) {
+    return false;
+  }
+}
+
+async function checkHttpUrl(url, timeout = 5000) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    const res = await fetch(url, {
+      method: 'HEAD',
+      signal: controller.signal,
+      redirect: 'follow',
+    });
+    clearTimeout(timer);
+    return res.ok;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function checkResource(resource) {
+  const { type, pid, publicUrl } = resource;
+
+  if (type === 'tunnel') {
+    const alive = isProcessAlive(pid);
+    if (!alive) {
+      return { valid: false, reason: 'process_not_found', detail: `PID ${pid} 已终止` };
+    }
+  }
+
+  if (publicUrl) {
+    const reachable = await checkHttpUrl(publicUrl);
+    if (!reachable) {
+      return { valid: false, reason: 'http_unreachable', detail: `URL 不可访问: ${publicUrl}` };
+    }
+  }
+
+  return { valid: true, reason: 'ok' };
+}
+
+module.exports = {
+  isProcessAlive,
+  checkHttpUrl,
+  checkResource,
+};