@cc123hh/gitee-cli 0.0.0-stage → 0.4.0

package/lib/args.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * 极简参数解析器（零依赖，覆盖本项目用到的 argparse 子集）：
+ * 短/长选项、--opt=value、可重复选项、开关、整数、choices、
+ * 位置参数（必填/可选）、-h/--help。错误打印用法并 exit 2（对齐 argparse 约定）。
+ *
+ * spec: {
+ *   prog, usage, description,
+ *   options: [{ short, long, dest, arg: false|"value"|"int", repeat, choices, default, required, help }],
+ *   positionals: [{ dest, required, help }],
+ * }
+ */
+function die(spec, msg) {
+  console.error(`${msg}\n\n${usageText(spec)}`);
+  process.exit(2);
+}
+
+function optionNames(o) {
+  return [o.short, o.long].filter(Boolean);
+}
+
+function valueLabel(o) {
+  if (!o.arg) return "";
+  if (o.arg === "int") return " N";
+  const m = (o.long || o.short || "").replace(/^--?/, "").toUpperCase();
+  return ` ${m}`;
+}
+
+function usageText(spec) {
+  const parts = [];
+  for (const o of spec.options) {
+    if (o.required) {
+      parts.push(`${optionNames(o).join(", ")}${valueLabel(o)}`);
+    } else if (!o.arg) {
+      parts.push(`[${optionNames(o)[0]}]`);
+    } else {
+      parts.push(`[${optionNames(o).join(", ")}${valueLabel(o)}]`);
+    }
+  }
+  const pos = (spec.positionals || [])
+    .map((p) => (p.required ? `<${p.dest}>` : `[<${p.dest}>]`));
+  const head = spec.usage || `用法：${spec.prog} ${parts.concat(pos).join(" ")}`;
+  return head;
+}
+
+function helpText(spec) {
+  const lines = [usageText(spec)];
+  if (spec.description) lines.push("", spec.description);
+  lines.push("", "选项：");
+  for (const o of spec.options) {
+    const left = `${optionNames(o).join(", ")}${valueLabel(o)}`;
+    lines.push(`  ${left.padEnd(26)}${o.help || ""}`);
+  }
+  for (const p of spec.positionals || []) {
+    lines.push(`  ${`<${p.dest}>`.padEnd(26)}${p.help || ""}`);
+  }
+  return lines.join("\n");
+}
+
+function parseIntStrict(s) {
+  if (!/^-?\d+$/.test(s)) return NaN;
+  return parseInt(s, 10);
+}
+
+/** 解析 argv，返回 { opts, positionals }。 */
+function parse(spec, argv) {
+  const opts = {};
+  const byToken = new Map();
+  for (const o of spec.options) {
+    if (o.default !== undefined) opts[o.dest] = o.default;
+    for (const t of optionNames(o)) byToken.set(t, o);
+  }
+  const repeatable = new Set();
+  const positionals = [];
+  let noMoreOptions = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (!noMoreOptions && (t === "-h" || t === "--help")) {
+      console.log(helpText(spec));
+      process.exit(0);
+    }
+    if (!noMoreOptions && t === "--") {
+      noMoreOptions = true;
+      continue;
+    }
+    const looksLikeOption = !noMoreOptions && t.startsWith("-") && t !== "-" && !/^-?\d+$/.test(t);
+    if (looksLikeOption) {
+      let token = t;
+      let inlineVal;
+      const eq = t.indexOf("=");
+      if (eq > 0 && t.startsWith("--")) {
+        token = t.slice(0, eq);
+        inlineVal = t.slice(eq + 1);
+      }
+      const o = byToken.get(token);
+      if (!o) die(spec, `错误：未知选项 ${t}`);
+      if (!o.arg) {
+        if (inlineVal !== undefined) die(spec, `错误：${token} 不接受值`);
+        opts[o.dest] = true;
+        continue;
+      }
+      let val = inlineVal;
+      if (val === undefined) {
+        i += 1;
+        if (i >= argv.length) die(spec, `错误：${token} 需要一个参数`);
+        val = argv[i];
+      }
+      if (o.arg === "int") {
+        const n = parseIntStrict(val);
+        if (Number.isNaN(n)) die(spec, `错误：${token} 需要整数，收到 ${val}`);
+        val = n;
+      }
+      if (o.choices && !o.choices.includes(val)) {
+        die(spec, `错误：${token} 的取值应为 ${o.choices.join(" / ")}，收到 ${val}`);
+      }
+      if (o.repeat) {
+        if (!repeatable.has(o.dest)) {
+          repeatable.add(o.dest);
+          opts[o.dest] = [];
+        }
+        opts[o.dest].push(val);
+      } else {
+        opts[o.dest] = val;
+      }
+      continue;
+    }
+    positionals.push(t);
+  }
+
+  const posSpecs = spec.positionals || [];
+  const variadic = posSpecs.some((p) => p.variadic);
+  if (!variadic) {
+    const maxPos = posSpecs.length;
+    if (positionals.length > maxPos && maxPos > 0) {
+      die(spec, `错误：多余的位置参数 ${positionals[maxPos]}`);
+    }
+  }
+  let consumed = 0;
+  posSpecs.forEach((p, idx) => {
+    if (p.variadic) {
+      const rest = positionals.slice(idx);
+      if (p.required && !rest.length) die(spec, `错误：缺少必需参数 <${p.dest}>`);
+      opts[p.dest] = rest;
+      consumed = positionals.length;
+      return;
+    }
+    if (p.required && (positionals[idx] === undefined || positionals[idx] === "")) {
+      die(spec, `错误：缺少必需参数 <${p.dest}>`);
+    }
+    opts[p.dest] = positionals[idx];
+    consumed = idx + 1;
+  });
+  if (variadic && consumed < positionals.length) {
+    die(spec, `错误：多余的位置参数 ${positionals[consumed]}`);
+  }
+  for (const o of spec.options) {
+    if (o.required && (opts[o.dest] === undefined || opts[o.dest] === null)) {
+      die(spec, `错误：缺少必需选项 ${optionNames(o).join(" / ")}`);
+    }
+  }
+  return { opts, positionals };
+}
+
+module.exports = { parse, usageText, helpText };

package/lib/config.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * 内部配置模块（零依赖）。
+ * 与 Python 版 os.path.expanduser 对齐：HOME 优先，其次 USERPROFILE——
+ * 不能用 os.homedir()（Windows 上它忽略 HOME），否则两边读写不同目录。
+ */
+const fs = require("fs");
+const path = require("path");
+
+function homedir() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+
+/** 配置项名归一化：api-key / api_key / API-KEY 均映射到 JSON key。 */
+function normKey(name, validKeys) {
+  const key = String(name).trim().toLowerCase().replace(/-/g, "_");
+  return validKeys.includes(key) ? key : null;
+}
+
+/** 读取内部配置；文件缺失返回空对象，损坏则警告并忽略（不阻断命令）。 */
+function loadConfig(configPath, validKeys) {
+  try {
+    const data = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const out = {};
+      for (const k of Object.keys(data)) if (validKeys.includes(k)) out[k] = data[k];
+      return out;
+    }
+    console.error(`警告：配置文件格式异常（应为 JSON 对象），已忽略：${configPath}`);
+  } catch (e) {
+    if (e && e.code === "ENOENT") return {};
+    console.error(`警告：读取配置文件失败，已忽略：${e && e.message}`);
+  }
+  return {};
+}
+
+/** 原子写入配置（临时文件 + rename），权限收紧到 600（内含敏感值）。 */
+function saveConfig(configPath, cfg) {
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  const tmp = configPath + ".tmp";
+  const ordered = {};
+  for (const k of Object.keys(cfg).sort()) ordered[k] = cfg[k];
+  // 与 Python 版形态一致：sort_keys + 2 空格缩进 + 尾换行 + 非 ASCII 不转义
+  fs.writeFileSync(tmp, JSON.stringify(ordered, null, 2) + "\n");
+  try {
+    fs.chmodSync(tmp, 0o600); // Windows 上意义有限，失败不阻断
+  } catch (_) { /* 忽略 */ }
+  fs.renameSync(tmp, configPath);
+}
+
+/** 敏感值脱敏显示：保留首尾各 4 位，中间打码。 */
+function maskSecret(value) {
+  const s = String(value);
+  if (s.length <= 8) return "*".repeat(s.length);
+  return `${s.slice(0, 4)}…${s.slice(-4)}（${s.length} 位）`;
+}
+
+function displayValue(secret, value) {
+  return secret ? maskSecret(value) : String(value);
+}
+
+/** 单项配置四层解析（命令行 > 内部配置 > 环境变量 > 默认），返回 [生效值, 来源]。 */
+function resolveValue(cliVal, cfgVal, envName, defaultVal) {
+  if (cliVal !== undefined && cliVal !== null) return [cliVal, "命令行参数"];
+  if (cfgVal !== undefined && cfgVal !== null && cfgVal !== "") return [cfgVal, "内部配置"];
+  const envVal = envName ? process.env[envName] : undefined;
+  if (envVal) return [envVal, `环境变量 ${envName}`];
+  return [defaultVal, "内置默认值"];
+}
+
+// ---- 终端对齐辅助：CJK 等全角字符按 2 列计 ----
+function dispWidth(text) {
+  let n = 0;
+  for (const ch of text) n += ch.codePointAt(0) > 0x2e7f ? 2 : 1;
+  return n;
+}
+
+function dispPad(text, width) {
+  return text + " ".repeat(Math.max(width - dispWidth(text), 1));
+}
+
+/**
+ * 列出各配置项当前生效值与来源（set 不带参数时）。
+ * rows: [{ label, key, env, default, secret, legacyFn?, legacyLabel? }]
+ */
+function showConfig(rows, configPath, labelWidth) {
+  const w = labelWidth || 10;
+  console.log(`配置文件：${configPath}\n`);
+  console.log(dispPad("项", w) + dispPad("当前生效值", 46) + "来源");
+  for (const r of rows) {
+    const cfgVal = r.cfg ? r.cfg[r.key] : undefined;
+    let value;
+    let source;
+    if (cfgVal !== undefined && cfgVal !== null && cfgVal !== "") {
+      value = String(cfgVal);
+      source = "内部配置";
+    } else if (r.legacyFn && r.legacyFn()) {
+      value = r.legacyFn();
+      source = r.legacyLabel;
+    } else if (r.env && process.env[r.env]) {
+      value = process.env[r.env];
+      source = `环境变量 ${r.env}`;
+    } else {
+      value = r.default !== undefined && r.default !== null ? String(r.default) : "（未设置）";
+      source = r.default !== undefined && r.default !== null ? "内置默认值" : "—";
+    }
+    if (r.secret && value !== "（未设置）") value = maskSecret(value);
+    // 内部配置覆盖了环境变量时提示被忽略的值，便于排查「环境变量为何不生效」
+    if (source === "内部配置" && r.env && process.env[r.env]
+        && process.env[r.env] !== String(cfgVal)) {
+      source += `（环境变量 ${r.env} 被忽略）`;
+    }
+    console.log(dispPad(r.label, w) + dispPad(value, 46) + source);
+  }
+}
+
+module.exports = {
+  homedir,
+  normKey,
+  loadConfig,
+  saveConfig,
+  maskSecret,
+  displayValue,
+  resolveValue,
+  dispWidth,
+  dispPad,
+  showConfig,
+};

package/lib/httputil.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * HTTP 辅助（零依赖）：直连 / http 代理（CONNECT 隧道或纯 http 转发），
+ * 整包读响应，把非 2xx 也原样返回——重试与错误语义由调用方分层决定。
+ */
+const http = require("http");
+const https = require("https");
+const net = require("net");
+const tls = require("tls");
+const { URL } = require("url");
+
+class HttpError extends Error {
+  constructor(status, detail, url) {
+    super(`HTTP ${status}${detail ? `：${detail}` : ""}${url ? `（${url}）` : ""}`);
+    this.status = status;
+    this.detail = detail || "";
+    this.url = url || "";
+  }
+}
+
+class TimeoutError extends Error {
+  constructor() {
+    super("请求超时");
+  }
+}
+
+function withTimeout(promise, timeoutMs, makeError) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(makeError()), timeoutMs);
+    }),
+  ]).finally(() => clearTimeout(timer));
+}
+
+/** TCP 连到代理并完成 CONNECT 隧道握手，返回裸 socket。 */
+function connectViaProxy(proxyUrl, targetUrl, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const sock = net.connect({
+      host: proxyUrl.hostname,
+      port: Number(proxyUrl.port || 80),
+    });
+    const fail = (err) => {
+      sock.destroy();
+      reject(err);
+    };
+    const timer = setTimeout(() => fail(new TimeoutError()), timeoutMs);
+    sock.on("error", (e) => {
+      clearTimeout(timer);
+      fail(new Error(`代理连接失败：${e.message}`));
+    });
+    sock.on("connect", () => {
+      sock.write(
+        `CONNECT ${targetUrl.hostname}:${targetUrl.port || 443} HTTP/1.1\r\n`
+        + `Host: ${targetUrl.hostname}:${targetUrl.port || 443}\r\n\r\n`);
+    });
+    let buf = "";
+    sock.on("data", function onData(d) {
+      buf += d.toString("latin1");
+      if (!buf.includes("\r\n\r\n")) return;
+      clearTimeout(timer);
+      sock.removeListener("data", onData);
+      const line = buf.split("\r\n")[0];
+      if (!/^HTTP\/1\.[01] 200/.test(line)) {
+        sock.destroy();
+        reject(new Error(`代理 CONNECT 失败：${line}`));
+        return;
+      }
+      resolve(sock);
+    });
+  });
+}
+
+/** 在既有裸 socket 上做 TLS 握手（SNI 用目标主机名）。 */
+function tlsWrap(sock, hostname, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const tlsSock = tls.connect({ socket: sock, servername: hostname });
+    const timer = setTimeout(() => {
+      tlsSock.destroy();
+      reject(new TimeoutError());
+    }, timeoutMs);
+    tlsSock.once("secureConnect", () => {
+      clearTimeout(timer);
+      resolve(tlsSock);
+    });
+    tlsSock.once("error", (e) => {
+      clearTimeout(timer);
+      reject(new Error(`TLS 握手失败：${e.message}`));
+    });
+  });
+}
+
+/**
+ * 单次 HTTP 请求。
+ * opts: { urlStr, method, headers, body(Buffer|string|null), proxy, timeoutSec }
+ * 返回 { status, headers, body:Buffer }；网络错误/超时抛异常（含 TimeoutError）。
+ */
+function requestOnce(opts) {
+  const { urlStr, method = "GET", headers = {}, body = null,
+    proxy, timeoutSec = 120 } = opts;
+  const u = new URL(urlStr);
+  const isHttps = u.protocol === "https:";
+  if (!isHttps && u.protocol !== "http:") {
+    return Promise.reject(new Error(`不支持的协议：${u.protocol}`));
+  }
+  const timeoutMs = Math.max(1, Number(timeoutSec)) * 1000;
+
+  const sendHeaders = { ...headers };
+  if (body !== null && body !== undefined
+      && !Object.keys(sendHeaders).some((k) => k.toLowerCase() === "content-length")) {
+    sendHeaders["Content-Length"] = Buffer.byteLength(body);
+  }
+
+  const collect = (req) => new Promise((resolve, reject) => {
+    req.setTimeout(timeoutMs, () => req.destroy(new TimeoutError()));
+    req.on("error", reject);
+    req.on("response", (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        resolve({ status: res.statusCode, headers: res.headers, body: Buffer.concat(chunks) });
+      });
+      res.on("error", reject);
+    });
+    if (body !== null && body !== undefined) req.write(body);
+    req.end();
+  });
+
+  if (!proxy) {
+    // 直连：交给 http/https 模块自己建连
+    const lib = isHttps ? https : http;
+    const req = lib.request(urlStr, {
+      method,
+      headers: sendHeaders,
+      agent: false,
+    });
+    return new Promise((resolve, reject) => {
+      req.setTimeout(timeoutMs, () => req.destroy(new TimeoutError()));
+      req.on("error", reject);
+      req.on("response", (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          resolve({ status: res.statusCode, headers: res.headers, body: Buffer.concat(chunks) });
+        });
+        res.on("error", reject);
+      });
+      if (body !== null && body !== undefined) req.write(body);
+      req.end();
+    });
+  }
+
+  const p = new URL(proxy);
+  if (p.protocol !== "http:") {
+    return Promise.reject(new Error(`仅支持 http:// 代理：${proxy}`));
+  }
+  if (!isHttps) {
+    // 纯 http 目标经 http 代理：向代理发绝对 URI（RFC 7230 §5.3.2）
+    const req = http.request({
+      host: p.hostname,
+      port: Number(p.port || 80),
+      path: urlStr,
+      method,
+      headers: sendHeaders,
+      agent: false,
+      createConnection: () => net.connect({ host: p.hostname, port: Number(p.port || 80) }),
+    });
+    return collect(req);
+  }
+  // https 目标经 http 代理：CONNECT 隧道 + TLS
+  return (async () => {
+    const raw = await withTimeout(
+      connectViaProxy(p, u, timeoutMs), timeoutMs, () => new TimeoutError());
+    const tlsSock = await withTimeout(
+      tlsWrap(raw, u.hostname, timeoutMs), timeoutMs, () => new TimeoutError());
+    const req = https.request({
+      host: u.hostname,
+      port: Number(u.port || 443),
+      path: u.pathname + u.search,
+      method,
+      headers: sendHeaders,
+      agent: false,
+      servername: u.hostname,
+      createConnection: () => tlsSock,
+    });
+    return collect(req);
+  })();
+}
+
+/** GET 下载，跟随 301/302/303/307/308（上限 maxRedirects）。 */
+async function download(urlStr, { proxy, timeoutSec = 120, headers = {}, maxRedirects = 5 } = {}) {
+  let current = urlStr;
+  for (let i = 0; i <= maxRedirects; i++) {
+    const res = await requestOnce({ urlStr: current, method: "GET", headers, proxy, timeoutSec });
+    if ([301, 302, 303, 307, 308].includes(res.status) && res.headers.location) {
+      current = new URL(res.headers.location, current).href;
+      continue;
+    }
+    if (res.status !== 200) {
+      throw new HttpError(res.status, "", current);
+    }
+    return res.body;
+  }
+  throw new Error("重定向次数过多");
+}
+
+module.exports = { requestOnce, download, HttpError, TimeoutError };

package/package.json

@@ -1,6 +1,24 @@
-{
-  "name": "@cc123hh/gitee-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@cc123hh/gitee-cli",
+  "version": "0.4.0",
+  "description": "Gitee 仓库管理命令行工具——纯 Node 零依赖实现",
+  "bin": {
+    "gitee": "bin/gitee.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "gitee",
+    "cli",
+    "git",
+    "repository"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  }
+}