@aweray/hsk-cli 0.2.2

package/lib/resourceStore.js

@@ -0,0 +1,112 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * 查找项目根目录（向上查找 package.json）
+ */
+function findProjectRoot(cwd = process.cwd()) {
+  let current = cwd;
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, 'package.json'))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return null;
+}
+
+/**
+ * 获取资源文件路径（项目绑定，找不到项目则回退到全局）
+ */
+function getResourceFilePath() {
+  const projectRoot = findProjectRoot();
+  if (projectRoot) {
+    return path.join(projectRoot, '.hsk', 'resources.json');
+  }
+  return path.join(os.homedir(), '.hsk', 'resources.json');
+}
+
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function readStore() {
+  const filePath = getResourceFilePath();
+  if (!fs.existsSync(filePath)) {
+    return { version: 1, resources: [] };
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return data || { version: 1, resources: [] };
+  } catch (e) {
+    return { version: 1, resources: [] };
+  }
+}
+
+function writeStore(data) {
+  const filePath = getResourceFilePath();
+  ensureDir(filePath);
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch (e) {}
+}
+
+function findResource(predicate) {
+  const store = readStore();
+  return store.resources.find(predicate) || null;
+}
+
+function findTunnel(ip, port) {
+  return findResource(
+    (r) => r.type === 'tunnel' && r.localIp === ip && r.localPort === port
+  );
+}
+
+function saveResource(resource) {
+  const store = readStore();
+  const index = store.resources.findIndex((r) => r.id === resource.id);
+  if (index >= 0) {
+    store.resources[index] = { ...store.resources[index], ...resource };
+  } else {
+    store.resources.push(resource);
+  }
+  writeStore(store);
+}
+
+function updateResourceStatus(id, status) {
+  const store = readStore();
+  const resource = store.resources.find((r) => r.id === id);
+  if (resource) {
+    resource.status = status;
+    resource.lastCheckedAt = new Date().toISOString();
+    writeStore(store);
+  }
+}
+
+function removeResource(id) {
+  const store = readStore();
+  store.resources = store.resources.filter((r) => r.id !== id);
+  writeStore(store);
+}
+
+function getAllResources() {
+  return readStore().resources;
+}
+
+module.exports = {
+  findProjectRoot,
+  getResourceFilePath,
+  readStore,
+  writeStore,
+  findResource,
+  findTunnel,
+  saveResource,
+  updateResourceStatus,
+  removeResource,
+  getAllResources,
+};

package/lib/tunnel.js

@@ -0,0 +1,192 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const download = require('./download');
+const platform = require('./platform');
+const pidManager = require('./pidManager');
+const resourceStore = require('./resourceStore');
+const resourceChecker = require('./resourceChecker');
+
+async function start(options) {
+  const { ip, port, arch, detached = false, reuse = false } = options;
+
+  const portNum = Number(port);
+  if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+    throw new Error('端口号必须是 1-65535 之间的有效数字');
+  }
+
+  const resourceId = `tunnel-${ip}-${portNum}`;
+
+  // === --reuse: 检查是否已有活跃隧道 ===
+  if (reuse) {
+    const existing = resourceStore.findTunnel(ip, portNum);
+    if (existing) {
+      const check = await resourceChecker.checkResource(existing);
+      if (check.valid) {
+        return {
+          success: true,
+          publicUrl: existing.publicUrl,
+          ip,
+          port: portNum,
+          binary: path.basename(existing.binary || ''),
+          pid: existing.pid,
+          detached: existing.detached,
+          reused: true,
+        };
+      }
+      // 失效则删除旧记录
+      resourceStore.removeResource(existing.id);
+    }
+  }
+
+  const binPath = await download.ensureBinary(arch);
+  const args = ['-ip', ip, '-port', String(portNum)];
+
+  if (detached) {
+    const logFile = pidManager.getLogFilePath('tunnel', { ip, port: portNum });
+    const out = fs.openSync(logFile, 'a');
+    const err = fs.openSync(logFile, 'a');
+
+    const proc = spawn(binPath, args, {
+      stdio: ['ignore', out, err],
+      detached: true,
+      windowsHide: true
+    });
+
+    proc.unref();
+    fs.closeSync(out);
+    fs.closeSync(err);
+
+    pidManager.savePid('tunnel', { ip, port: portNum }, proc.pid);
+
+    resourceStore.saveResource({
+      id: resourceId,
+      type: 'tunnel',
+      localIp: ip,
+      localPort: portNum,
+      publicUrl: null,
+      pid: proc.pid,
+      binary: path.basename(binPath),
+      detached: true,
+      logFile,
+      status: 'running',
+      createdAt: new Date().toISOString(),
+      lastCheckedAt: new Date().toISOString(),
+    });
+
+    return {
+      success: true,
+      publicUrl: null,
+      ip,
+      port: portNum,
+      binary: path.basename(binPath),
+      pid: proc.pid,
+      detached: true,
+      logFile,
+      reused: false,
+    };
+  }
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(binPath, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let urlCaptured = null;
+    let timeoutId;
+    let isResolved = false;
+
+    proc.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      process.stdout.write(chunk);
+
+      if (!urlCaptured) {
+        const urlMatch = chunk.match(/(https?:\/\/[^\s\n]+)/);
+        if (urlMatch) {
+          urlCaptured = urlMatch[1];
+          clearTimeout(timeoutId);
+          isResolved = true;
+
+          resourceStore.saveResource({
+            id: resourceId,
+            type: 'tunnel',
+            localIp: ip,
+            localPort: portNum,
+            publicUrl: urlCaptured,
+            pid: proc.pid,
+            binary: path.basename(binPath),
+            detached: false,
+            status: 'running',
+            createdAt: new Date().toISOString(),
+            lastCheckedAt: new Date().toISOString(),
+          });
+
+          resolve({
+            success: true,
+            publicUrl: urlCaptured,
+            ip,
+            port: portNum,
+            binary: path.basename(binPath),
+            pid: proc.pid,
+            detached: false,
+            reused: false,
+            stdout: stdout.trim(),
+            stderr: stderr.trim()
+          });
+        }
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      const chunk = data.toString();
+      stderr += chunk;
+      process.stderr.write(chunk);
+    });
+
+    timeoutId = setTimeout(() => {
+      if (!isResolved) {
+        proc.kill();
+        reject(new Error('启动超时（30秒），请检查网络连接或本地服务是否可用。\n输出: ' + stdout + '\n错误: ' + stderr));
+      }
+    }, 30000);
+
+    proc.on('error', (err) => {
+      clearTimeout(timeoutId);
+      if (!isResolved) {
+        reject(new Error(`无法启动客户端: ${err.message}`));
+      }
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeoutId);
+      if (!isResolved) {
+        if (code !== 0) {
+          reject(new Error(`客户端异常退出 (code: ${code})\n输出: ${stdout}\n错误: ${stderr}`));
+        } else {
+          reject(new Error('未能从输出中解析到公网地址。\n输出: ' + stdout));
+        }
+      } else {
+        console.log('\n' + chalk.yellow('⚠️  隧道已断开（客户端进程退出）'));
+        resourceStore.updateResourceStatus(resourceId, 'stopped');
+        process.exit(0);
+      }
+    });
+
+    process.on('SIGINT', () => {
+      console.log('\n' + '⏹️  正在停止隧道...');
+      try { proc.kill('SIGTERM'); } catch (e) {}
+      setTimeout(() => { try { proc.kill('SIGKILL'); } catch (e) {} }, 2000);
+    });
+
+    process.on('SIGTERM', () => {
+      try { proc.kill('SIGTERM'); } catch (e) {}
+    });
+  });
+}
+
+module.exports = { start };

package/lib/version.js

@@ -0,0 +1,3 @@
+const { version } = require('../package.json');
+
+module.exports = version;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@aweray/hsk-cli",
+  "version": "0.2.2",
+  "description": "HSK CLI - 内网穿透 & 文件托管，支持 Windows/macOS/Linux 多平台",
+  "main": "index.js",
+  "bin": {
+    "hsk-cli": "bin/hsk-cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Tests not implemented yet\" && exit 0"
+  },
+  "keywords": [
+    "hsk",
+    "tunnel",
+    "nat-traversal",
+    "file-hosting",
+    "cli",
+    "内网穿透",
+    "文件托管",
+    "ai-agent",
+    "remote-access"
+  ],
+  "author": "HSK Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "commander": "^11.0.0",
+    "chalk": "^4.1.2",
+    "node-fetch": "^2.7.0",
+    "form-data": "^4.0.0"
+  },
+  "homepage": "https://hsk.oray.com",
+  "files": [
+    "bin/",
+    "lib/",
+    "index.js",
+    "README.md",
+    "versions.json"
+  ]
+}

package/versions.json

@@ -0,0 +1,18 @@
+{
+  "version": "0.2.2",
+  "downloadBaseUrl": "https://dw.oray.com/onion/cli",
+  "binaries": {
+    "windows-amd64": {
+      "filename": "hsk-cli-windows-amd64-v0.2.2.exe"
+    },
+    "darwin-amd64": {
+      "filename": "hsk-cli-darwin-amd64-v0.2.2"
+    },
+    "darwin-arm64": {
+      "filename": "hsk-cli-darwin-arm64-v0.2.2"
+    },
+    "linux-amd64": {
+      "filename": "hsk-cli-linux-amd64-v0.2.2"
+    }
+  }
+}