@cc123hh/gitee-cli 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cc123hh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,218 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<h1 align="center">gitee</h1>
+
+<p align="center">
+  <img src="https://gitee.com/cc123hh/gitee-cli/raw/main/docs/banner.jpg" alt="gitee banner" width="760">
+</p>
+
+<p align="center">
+  <img src="https://gitee.com/cc123hh/gitee-cli/raw/main/docs/badges/python.svg" alt="python 3.8+">
+  <img src="https://gitee.com/cc123hh/gitee-cli/raw/main/docs/badges/platform.svg" alt="platform">
+  <img src="https://gitee.com/cc123hh/gitee-cli/raw/main/docs/badges/deps.svg" alt="dependencies">
+  <img src="https://gitee.com/cc123hh/gitee-cli/raw/main/docs/badges/tests.svg" alt="tests">
+  <img src="https://gitee.com/cc123hh/gitee-cli/raw/main/docs/badges/license.svg" alt="license">
+</p>
+
+<p align="center">
+  <b>在终端里把 Gitee 管起来：建仓、推送、看 Issue，一条命令。</b><br>
+  零依赖 · 跨平台 · 单文件脚本 · 直接调 Gitee OpenAPI v5
+</p>
+
+---
+
+## 📑 目录
+
+- [快速开始](#-快速开始)
+- [特性](#-特性)
+- [安装](#-安装)
+- [配置](#-配置)
+- [命令一览](#-命令一览)
+- [常见问题](#-常见问题)
+- [License](#license)
+
+## 🚀 快速开始
+
+```console
+$ gitee list
+仓库                                             可见性    ★    更新
+--------------------------------------------------------------------
+cc123hh/imgen-cli                                公开      0   2026-11-04 13:15
+cc123hh/emb-cli                                  公开      0   2026-11-04 12:40
+cc123hh/private-notes                            私有      0   2026-11-03 21:08
+
+$ gitee info emb-cli
+仓库:   cc123hh/emb-cli
+地址:   https://gitee.com/cc123hh/emb-cli
+可见性: 公开
+统计:   ★ 0  Fork 0  Watch 1
+默认分支: main
+
+$ cd ~/Scripts/new-tool && gitee push --public -d "我的新工具"
+仓库不存在，正在创建 cc123hh/new-tool …
+推送 main → https://gitee.com/cc123hh/new-tool.git …
+已添加 remote origin
+已设为公开
+完成：https://gitee.com/cc123hh/new-tool
+```
+
+## ✨ 特性
+
+| | |
+|---|---|
+| 🪶 **零依赖** | Python 版只用标准库；npm 版纯 Node 内置模块，双实现 |
+| 🖥️ **跨平台** | macOS / Linux / Windows，安装脚本全覆盖 |
+| 📦 **仓库管理** | 列出、查看、创建、删除、公开/私有切换 |
+| 🚀 **建仓推送一体** | `gitee push` 自动建仓 + 推送 + 设可见性 |
+| 📋 **Issue / PR** | 命令行直接看列表与状态 |
+| 🀄 **中文对齐** | 表格按中日韩字符显示宽度排版，不乱 |
+| 🔒 **令牌不落库** | 只从 `GITEE_TOKEN` 读取 |
+
+## 📥 安装
+
+> 前提：Python 3.8+（npm 版为纯 JS，只需 Node ≥ 16）
+
+### macOS / Linux
+
+```bash
+git clone https://gitee.com/cc123hh/gitee-cli.git
+cd gitee-cli
+./install.sh
+```
+
+### Windows
+
+```powershell
+git clone https://gitee.com/cc123hh/gitee-cli.git
+cd gitee-cli
+powershell -ExecutionPolicy Bypass -File .\install.ps1
+```
+
+免安装直接用：`gitee.cmd list`
+
+### 所有平台（pipx）
+
+```bash
+pipx install git+https://gitee.com/cc123hh/gitee-cli.git
+```
+
+### 所有平台（npm / pnpm）
+
+纯 Node 实现（无需 Python），装完即得 `gitee` 命令：
+
+```bash
+pnpm add -g @cc123hh/gitee-cli    # 或 npm i -g @cc123hh/gitee-cli
+```
+
+## ⚙️ 配置
+
+优先级（高 → 低）：**命令行参数（`--token` / `--api` / `--proxy` / `--timeout`）> 内部配置文件 > 环境变量 > 内置默认值**
+
+推荐用内部配置持久化（不依赖环境变量注入，GUI 进程 / 非交互 shell 也稳定可用）：
+
+```bash
+gitee set                       # 查看当前配置及来源（token 自动脱敏）
+gitee set token <TOKEN>         # 设置私人令牌（写入 ~/.config/gitee/config.json，600 权限）
+gitee set proxy <URL>           # 设置代理
+gitee unset token               # 删除某项
+```
+
+环境变量作为兜底层仍然支持：
+
+```bash
+# 必需（除非已 gitee set token）：私人令牌（https://gitee.com/profile/personal_access_tokens）
+export GITEE_TOKEN="你的令牌"
+
+# 可选
+export GITEE_API="https://gitee.com/api/v5"
+export GITEE_PROXY="http://127.0.0.1:7890"
+```
+
+Windows：`setx GITEE_TOKEN "你的令牌"`
+
+> 令牌权限建议只勾：`projects`（仓库读写）、`pull_requests`、`issues`。
+
+## 🧰 命令一览
+
+### 账号
+
+```bash
+gitee whoami
+```
+
+### 仓库
+
+```bash
+gitee list                       # 我的仓库（按更新时间）
+gitee list -n 50 --json          # 更多条数 / 原始 JSON
+gitee info emb-cli               # 详情
+gitee create my-tool -d "简介"    # 新建（默认私有）
+gitee create my-tool --public    # 尝试公开（空仓库需推送后生效）
+gitee public my-tool             # 设为公开
+gitee private my-tool            # 设为私有
+gitee delete my-tool -y          # 删除（-y 跳过确认）
+```
+
+### 一键建仓并推送
+
+```bash
+cd ~/Scripts/mytool
+gitee push --public -d "我的小工具"
+```
+
+会自动：检查仓库是否存在 → 不存在则创建 → `git push` → 添加 `origin` → 需要时设为公开。
+
+### Issue / Pull Request
+
+```bash
+gitee issues emb-cli             # 打开中的 Issue
+gitee issues emb-cli -s all -n 50
+gitee prs emb-cli
+```
+
+`repo` 参数写 `仓库名` 会自动补上你的用户名，也可以写完整的 `owner/repo`。
+
+## 📋 参数
+
+| 参数 | 适用命令 | 说明 |
+|---|---|---|
+| `-n/--limit` | list / issues / prs | 返回条数 |
+| `--json` | list | 输出原始 JSON |
+| `-s/--state` | issues / prs | `open` / `closed` / `all` |
+| `-y/--yes` | delete | 跳过确认 |
+| `-d/--description` | create / push | 仓库简介 |
+| `--public` | create / push | 目标可见性 |
+| `--name` | push | 仓库名（默认取目录名） |
+| `--api/--proxy/--timeout` | 全部 | 覆盖环境变量 |
+
+## ❓ 常见问题
+
+<details>
+<summary><b>提示鉴权失败（401/403）？</b></summary>
+
+检查 `GITEE_TOKEN` 是否有效、是否勾选 `projects` 权限；令牌过期请重新生成。
+</details>
+
+<details>
+<summary><b>创建时选了公开，结果还是私有？</b></summary>
+
+Gitee 限制空仓库不能设为公开。推送首个提交后再执行 `gitee public 仓库名`；用 `gitee push --public` 会自动在推送后切换。
+</details>
+
+<details>
+<summary><b>push 报「不是 git 仓库」？</b></summary>
+
+`gitee push` 不会替你 `git init`，只负责建仓与推送。请先初始化并提交。
+</details>
+
+<details>
+<summary><b>表格里中文对不齐？</b></summary>
+
+已按 `unicodedata.east_asian_width` 计算显示宽度；若终端字体非等宽仍可能有偏差，属字体问题。
+</details>
+
+## 🤝 贡献
+
+欢迎 Issue / PR。
+
+## License
+
+[MIT](https://gitee.com/cc123hh/gitee-cli/blob/main/LICENSE)

package/bin/gitee.js

@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * gitee — Gitee 仓库管理命令行工具（纯 Node 零依赖，调 Gitee OpenAPI v5）
+ *
+ * 用法示例：
+ *     gitee list                          # 列出我的仓库（按更新时间排序）
+ *     gitee info cc123hh/imgen-cli        # 查看某个仓库
+ *     gitee create my-tool -d "说明"       # 新建仓库（默认私有）
+ *     gitee public my-tool                # 设为公开
+ *     gitee delete my-tool -y             # 删除仓库
+ *     gitee push --public                 # 当前目录建仓并推送
+ *
+ * 配置优先级（高 → 低）：
+ *     1. 命令行参数（--token / --api / --proxy / --timeout，临时覆盖）
+ *     2. 内部配置文件（gitee set 写入，持久生效，推荐）
+ *     3. 环境变量（GITEE_TOKEN / GITEE_API / GITEE_PROXY）
+ *     4. 内置默认值
+ */
+const fs = require("fs");
+const path = require("path");
+const spawnSync = require("child_process").spawnSync;
+const readline = require("readline");
+const { homedir, normKey, loadConfig, saveConfig, displayValue,
+  resolveValue, showConfig } = require("../lib/config.js");
+const { requestOnce, TimeoutError } = require("../lib/httputil.js");
+const { parse } = require("../lib/args.js");
+
+const DEFAULT_API = "https://gitee.com/api/v5";
+const DEFAULT_TIMEOUT = 30;
+const EXIT_OK = 0, EXIT_USAGE = 2, EXIT_AUTH = 3, EXIT_API = 5, EXIT_GIT = 6;
+
+const CONFIG_PATH = path.join(homedir(), ".config", "gitee", "config.json");
+const CONFIG_KEYS = ["token", "api", "proxy", "timeout"];
+
+// --------------------------------------------------------------------------- //
+// 内部配置管理（gitee set / gitee unset）
+// --------------------------------------------------------------------------- //
+function configRows(cfg) {
+  return [
+    { label: "token", key: "token", env: "GITEE_TOKEN", default: null, secret: true, cfg },
+    { label: "api", key: "api", env: "GITEE_API", default: DEFAULT_API, cfg },
+    { label: "proxy", key: "proxy", env: "GITEE_PROXY", default: null, cfg },
+    { label: "timeout", key: "timeout", env: null, default: DEFAULT_TIMEOUT, cfg },
+  ];
+}
+
+function cmdSetConfig(opts) {
+  if (opts.key === undefined || opts.key === null) {
+    showConfig(configRows(loadConfig(CONFIG_PATH, CONFIG_KEYS)), CONFIG_PATH);
+    return EXIT_OK;
+  }
+  if (opts.value === undefined || opts.value === null) {
+    console.error(`用法：gitee set <key> <value>（可用 key：${CONFIG_KEYS.join(" / ")}，`
+      + "不带参数列出当前配置）");
+    return EXIT_USAGE;
+  }
+  const key = normKey(opts.key, CONFIG_KEYS);
+  if (!key) {
+    console.error(`错误：未知配置项 ${JSON.stringify(opts.key)}，可用：${CONFIG_KEYS.join(" / ")}`);
+    return EXIT_USAGE;
+  }
+  let value = opts.value;
+  if (key === "timeout") {
+    const n = Number(opts.value);
+    if (!Number.isInteger(n) || n <= 0) {
+      console.error(`错误：timeout 必须为正整数，收到 ${JSON.stringify(opts.value)}`);
+      return EXIT_USAGE;
+    }
+    value = n;
+  } else if (key === "api") {
+    value = opts.value.replace(/\/+$/, "");
+  }
+  const cfg = loadConfig(CONFIG_PATH, CONFIG_KEYS);
+  cfg[key] = value;
+  saveConfig(CONFIG_PATH, cfg);
+  console.log(`✅ 已写入 ${key} = ${displayValue(key === "token", value)}`);
+  console.log(`   配置文件：${CONFIG_PATH}`);
+  return EXIT_OK;
+}
+
+function cmdUnsetConfig(opts) {
+  const key = normKey(opts.key, CONFIG_KEYS);
+  if (!key) {
+    console.error(`错误：未知配置项 ${JSON.stringify(opts.key)}，可用：${CONFIG_KEYS.join(" / ")}`);
+    return EXIT_USAGE;
+  }
+  const cfg = loadConfig(CONFIG_PATH, CONFIG_KEYS);
+  if (!(key in cfg)) {
+    console.error(`错误：${opts.key} 未在内部配置中设置（配置文件：${CONFIG_PATH}）`);
+    return EXIT_USAGE;
+  }
+  delete cfg[key];
+  saveConfig(CONFIG_PATH, cfg);
+  console.log(`✅ 已删除配置项 ${key}`);
+  return EXIT_OK;
+}
+
+// --------------------------------------------------------------------------- //
+// HTTP 客户端
+// --------------------------------------------------------------------------- //
+class GiteeError extends Error {}
+
+class Client {
+  constructor(token, api, proxy, timeout) {
+    this.token = token;
+    this.api = api.replace(/\/+$/, "");
+    this.proxy = proxy;
+    this.timeout = timeout;
+  }
+
+  async _request(method, path, params, form) {
+    const q = new URLSearchParams();
+    for (const [k, v] of Object.entries(params || {})) q.set(k, String(v));
+    q.set("access_token", this.token);
+    const urlStr = `${this.api}${path}?${q.toString()}`;
+    const headers = {};
+    let body = null;
+    if (form) {
+      const f = new URLSearchParams();
+      for (const [k, v] of Object.entries(form)) f.set(k, String(v));
+      body = Buffer.from(f.toString(), "utf8");
+      headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    let res;
+    try {
+      res = await requestOnce({
+        urlStr, method, headers, body, proxy: this.proxy, timeoutSec: this.timeout,
+      });
+    } catch (e) {
+      const reason = e instanceof TimeoutError ? "timed out" : e.message;
+      throw new GiteeError(`网络错误：${reason}（可设置 GITEE_PROXY 走代理）`);
+    }
+    const text = res.body.toString("utf8");
+    if (res.status >= 400) {
+      const detail = text.slice(0, 300);
+      if (res.status === 401 || res.status === 403) {
+        throw new GiteeError(`鉴权失败（HTTP ${res.status}）：检查 GITEE_TOKEN 是否有效`
+          + ` / 权限是否足够。${detail}`);
+      }
+      if (res.status === 404) {
+        throw new GiteeError(`资源不存在（HTTP 404）：${path}`);
+      }
+      throw new GiteeError(`HTTP ${res.status}：${detail}`);
+    }
+    return text.trim() ? JSON.parse(text) : {};
+  }
+
+  get(path, params) { return this._request("GET", path, params); }
+  post(path, form) { return this._request("POST", path, null, form); }
+  patch(path, form) { return this._request("PATCH", path, null, form); }
+  delete(path) { return this._request("DELETE", path); }
+}
+
+// --------------------------------------------------------------------------- //
+// 终端对齐辅助
+// --------------------------------------------------------------------------- //
+function width(text) {
+  let n = 0;
+  for (const ch of text) n += ch.codePointAt(0) > 0x2e7f ? 2 : 1;
+  return n;
+}
+
+function pad(text, w) {
+  return text + " ".repeat(Math.max(0, w - width(text)));
+}
+
+// --------------------------------------------------------------------------- //
+// 命令实现
+// --------------------------------------------------------------------------- //
+async function cmdWhoami(client) {
+  const user = await client.get("/user");
+  console.log(`${user.login}  (${user.name || "未设置昵称"})`);
+  console.log(`  主页: ${user.html_url}`);
+  console.log(`  邮箱: ${user.email || "未公开"}`);
+  return EXIT_OK;
+}
+
+async function cmdList(client, opts) {
+  const repos = await client.get("/user/repos", {
+    sort: "updated", per_page: String(opts.limit), page: "1",
+  });
+  if (!repos.length) {
+    console.log("没有仓库");
+    return EXIT_OK;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(repos, null, 2));
+    return EXIT_OK;
+  }
+  const nameW = Math.max(...repos.map((r) => width(r.full_name || "")), 8) + 2;
+  const header = pad("仓库", nameW) + pad("可见性", 8) + "  ★    更新";
+  console.log(header);
+  console.log("-".repeat(width(header)));
+  for (const repo of repos) {
+    const vis = repo.private ? "私有" : "公开";
+    const stars = String(repo.stargazers_count ?? 0).padStart(3);
+    const updated = (repo.updated_at || "").slice(0, 16).replace("T", " ");
+    console.log(pad(repo.full_name || "", nameW) + pad(vis, 8) + `${stars}   ${updated}`);
+  }
+  return EXIT_OK;
+}
+
+async function splitRepo(name, client) {
+  // 把 'repo' 或 'owner/repo' 规范成 'owner/repo'
+  if (name.includes("/")) return name;
+  const user = await client.get("/user");
+  return `${user.login}/${name}`;
+}
+
+async function cmdInfo(client, opts) {
+  const full = await splitRepo(opts.repo, client);
+  const repo = await client.get(`/repos/${full}`);
+  console.log(`仓库:   ${repo.full_name}`);
+  console.log(`地址:   ${repo.html_url}`);
+  console.log(`可见性: ${repo.private ? "私有" : "公开"}`);
+  console.log(`描述:   ${repo.description || "（无）"}`);
+  console.log(`统计:   ★ ${repo.stargazers_count ?? 0}  `
+    + `Fork ${repo.forks_count ?? 0}  `
+    + `Watch ${repo.watchers_count ?? 0}`);
+  console.log(`默认分支: ${repo.default_branch}`);
+  console.log(`更新于: ${repo.updated_at}`);
+  return EXIT_OK;
+}
+
+async function cmdCreate(client, opts) {
+  const user = await client.get("/user");
+  const owner = user.login;
+  const form = { name: opts.name, private: opts.public ? "false" : "true" };
+  if (opts.description) form.description = opts.description;
+  const repo = await client.post("/user/repos", form);
+  const full = repo.full_name || `${owner}/${opts.name}`;
+  const actualPrivate = repo.private !== false;
+  console.log(`已创建: ${full}`);
+  if (opts.public && actualPrivate) {
+    console.log(`提示：Gitee 不允许空仓库直接设为公开，推送首个提交后执行 `
+      + `\`gitee public ${opts.name}\` 即可。`);
+  }
+  return EXIT_OK;
+}
+
+async function cmdSetVisibility(client, opts, privateMode) {
+  const full = await splitRepo(opts.repo, client);
+  await client.patch(`/repos/${full}`, {
+    name: full.split("/")[1],
+    private: privateMode ? "true" : "false",
+  });
+  const repo = await client.get(`/repos/${full}`);
+  console.log(`${full} 现在是${repo.private ? "私有" : "公开"}仓库`);
+  return EXIT_OK;
+}
+
+async function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+async function cmdDelete(client, opts) {
+  const full = await splitRepo(opts.repo, client);
+  if (!opts.yes) {
+    const answer = await ask(`确认删除 ${full}？（不可恢复，输入 yes 继续）：`);
+    if (answer !== "yes") {
+      console.log("已取消");
+      return EXIT_OK;
+    }
+  }
+  await client.delete(`/repos/${full}`);
+  console.log(`已删除 ${full}`);
+  return EXIT_OK;
+}
+
+async function parseRepoArg(opts, client) {
+  const name = opts.repo !== undefined && opts.repo !== null
+    ? opts.repo
+    : path.basename(process.cwd());
+  return splitRepo(name, client);
+}
+
+async function cmdIssues(client, opts) {
+  const full = await parseRepoArg(opts, client);
+  const items = await client.get(`/repos/${full}/issues`, {
+    state: opts.state, per_page: String(opts.limit),
+  });
+  if (!items.length) {
+    console.log(`${full}: 没有 Issue`);
+    return EXIT_OK;
+  }
+  for (const it of items) {
+    const user = (it.user && it.user.login) || "?";
+    console.log(`#${String(it.number).padEnd(5)} [${String(it.state).padEnd(6)}] `
+      + `${it.title}  @${user}`);
+  }
+  return EXIT_OK;
+}
+
+async function cmdPrs(client, opts) {
+  const full = await parseRepoArg(opts, client);
+  const items = await client.get(`/repos/${full}/pulls`, {
+    state: opts.state, per_page: String(opts.limit),
+  });
+  if (!items.length) {
+    console.log(`${full}: 没有 Pull Request`);
+    return EXIT_OK;
+  }
+  for (const it of items) {
+    const user = (it.user && it.user.login) || "?";
+    console.log(`#${String(it.number).padEnd(5)} [${String(it.state).padEnd(6)}] `
+      + `${it.title}  @${user}`);
+  }
+  return EXIT_OK;
+}
+
+function runGit(args, cwd) {
+  const r = spawnSync("git", args, { cwd, encoding: "utf8" });
+  return { code: r.status, out: r.stdout || "", err: r.stderr || "" };
+}
+
+async function cmdPush(client, opts) {
+  const cwd = process.cwd();
+  const dotGit = path.join(cwd, ".git");
+  if (!fs.existsSync(dotGit) || !fs.statSync(dotGit).isDirectory()) {
+    console.error("当前目录不是 git 仓库（缺少 .git）");
+    return EXIT_GIT;
+  }
+  const user = await client.get("/user");
+  const owner = user.login;
+  const name = opts.name || path.basename(cwd);
+  const full = `${owner}/${name}`;
+
+  let exists = true;
+  try {
+    await client.get(`/repos/${full}`);
+  } catch (e) {
+    if (e instanceof GiteeError && e.message.includes("404")) {
+      exists = false;
+    } else {
+      throw e;
+    }
+  }
+  if (!exists) {
+    console.log(`仓库不存在，正在创建 ${full} …`);
+    await client.post("/user/repos", {
+      name,
+      private: opts.public ? "false" : "true",
+      description: opts.description || "",
+    });
+  }
+
+  const branch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd).out.trim() || "master";
+  const remoteUrl = `https://gitee.com/${full}.git`;
+  const authUrl = `https://oauth2:${client.token}@gitee.com/${full}.git`;
+
+  console.log(`推送 ${branch} → ${remoteUrl} …`);
+  const result = runGit(["push", authUrl, `${branch}:${branch}`], cwd);
+  if (result.code !== 0) {
+    // 令牌不落终端：git 报错输出可能带完整 auth_url，先把 token 打码
+    console.error(`推送失败：${result.err.trim().replaceAll(client.token, "***").slice(0, 500)}`);
+    return EXIT_GIT;
+  }
+  if (runGit(["remote", "get-url", "origin"], cwd).code !== 0) {
+    runGit(["remote", "add", "origin", remoteUrl], cwd);
+    console.log("已添加 remote origin");
+  }
+  if (opts.public) {
+    await client.patch(`/repos/${full}`, { name, private: "false" });
+    console.log("已设为公开");
+  }
+  console.log(`完成：https://gitee.com/${full}`);
+  return EXIT_OK;
+}
+
+// --------------------------------------------------------------------------- //
+// 子命令表与入口
+// --------------------------------------------------------------------------- //
+function clientOpts() {
+  return [
+    { long: "--token", dest: "token", arg: "value", help: "私人令牌（优先级最高，临时用别的账号时用；注意会进 shell 历史）" },
+    { long: "--api", dest: "api", arg: "value", help: "API 根地址（优先级：命令行 > gitee set > GITEE_API > 官方地址）" },
+    { long: "--proxy", dest: "proxy", arg: "value", help: "代理地址（优先级：命令行 > gitee set > GITEE_PROXY）" },
+    { long: "--timeout", dest: "timeout", arg: "int", help: "超时秒数（优先级：命令行 > gitee set > 30）" },
+  ];
+}
+
+function spec(usage, description, options, positionals) {
+  return { prog: "gitee", usage, description, options, positionals: positionals || [] };
+}
+
+const STATE_OPTS = [
+  { short: "-s", long: "--state", dest: "state", arg: "value", default: "open",
+    choices: ["open", "closed", "all"], help: "状态（默认 open）" },
+  { short: "-n", long: "--limit", dest: "limit", arg: "int", default: 20, help: "条数（默认 20）" },
+];
+
+const SUBCOMMANDS = {
+  set: {
+    run: (opts) => cmdSetConfig(opts),
+    spec: spec("用法：gitee set [<key> <value>]",
+      "查看或写入内部配置（~/.config/gitee/config.json）",
+      [], [
+      { dest: "key", required: false, help: "配置项：token / api / proxy / timeout" },
+      { dest: "value", required: false, help: "要写入的值（不带任何参数时列出当前配置）" },
+    ]),
+    noAuth: true,
+  },
+  unset: {
+    run: (opts) => cmdUnsetConfig(opts),
+    spec: spec("用法：gitee unset <key>", "删除一项内部配置",
+      [], [{ dest: "key", required: true, help: "配置项：token / api / proxy / timeout" }]),
+    noAuth: true,
+  },
+  whoami: {
+    run: (client) => cmdWhoami(client),
+    spec: spec("用法：gitee whoami", "查看当前 token 对应的账号", clientOpts()),
+  },
+  list: {
+    run: (client, o) => cmdList(client, o),
+    spec: spec("用法：gitee list [-n 条数] [--json]", "列出我的仓库",
+      [...STATE_OPTS.slice(1), { long: "--json", dest: "json", help: "输出原始 JSON" },
+        ...clientOpts()]),
+  },
+  info: {
+    run: (client, o) => cmdInfo(client, o),
+    spec: spec("用法：gitee info <repo>", "查看仓库信息", clientOpts(),
+      [{ dest: "repo", required: true, help: "仓库名或 owner/repo" }]),
+  },
+  create: {
+    run: (client, o) => cmdCreate(client, o),
+    spec: spec("用法：gitee create <name> [-d 简介] [--public]", "新建仓库",
+      [{ short: "-d", long: "--description", dest: "description", arg: "value", help: "仓库简介" },
+        { long: "--public", dest: "public", help: "设为公开（空仓库需推送后生效）" },
+        ...clientOpts()],
+      [{ dest: "name", required: true, help: "仓库名" }]),
+  },
+  public: {
+    run: (client, o) => cmdSetVisibility(client, o, false),
+    spec: spec("用法：gitee public <repo>", "把仓库设为公开", clientOpts(),
+      [{ dest: "repo", required: true, help: "仓库名或 owner/repo" }]),
+  },
+  private: {
+    run: (client, o) => cmdSetVisibility(client, o, true),
+    spec: spec("用法：gitee private <repo>", "把仓库设为私有", clientOpts(),
+      [{ dest: "repo", required: true, help: "仓库名或 owner/repo" }]),
+  },
+  delete: {
+    run: (client, o) => cmdDelete(client, o),
+    spec: spec("用法：gitee delete <repo> [-y]", "删除仓库",
+      [{ short: "-y", long: "--yes", dest: "yes", help: "跳过确认" }, ...clientOpts()],
+      [{ dest: "repo", required: true, help: "仓库名或 owner/repo" }]),
+  },
+  issues: {
+    run: (client, o) => cmdIssues(client, o),
+    spec: spec("用法：gitee issues [<repo>] [-s 状态] [-n 条数]", "列出 Issue",
+      [...STATE_OPTS, ...clientOpts()],
+      [{ dest: "repo", required: false, help: "仓库名或 owner/repo（默认当前目录同名仓库）" }]),
+  },
+  prs: {
+    run: (client, o) => cmdPrs(client, o),
+    spec: spec("用法：gitee prs [<repo>] [-s 状态] [-n 条数]", "列出 Pull Request",
+      [...STATE_OPTS, ...clientOpts()],
+      [{ dest: "repo", required: false, help: "仓库名或 owner/repo（默认当前目录同名仓库）" }]),
+  },
+  push: {
+    run: (client, o) => cmdPush(client, o),
+    spec: spec("用法：gitee push [--name 名字] [-d 简介] [--public]", "当前目录建仓并推送",
+      [{ long: "--name", dest: "name", arg: "value", help: "仓库名（默认取目录名）" },
+        { short: "-d", long: "--description", dest: "description", arg: "value", help: "仓库简介" },
+        { long: "--public", dest: "public", help: "推送后设为公开" },
+        ...clientOpts()]),
+  },
+};
+
+const TOP_HELP = `gitee — Gitee 仓库管理命令行工具
+
+用法：gitee <子命令> [参数]
+
+子命令：
+  set / unset   内部配置管理（token / api / proxy / timeout）
+  whoami        查看当前 token 对应的账号
+  list          列出我的仓库
+  info <repo>   查看仓库信息
+  create        新建仓库
+  public/private 切换仓库可见性
+  delete        删除仓库
+  issues / prs  列出 Issue / Pull Request
+  push          当前目录建仓并推送
+
+用 \`gitee <子命令> -h\` 查看各子命令详情。`;
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  if (!cmd) {
+    console.error(`错误：缺少子命令\n\n${TOP_HELP}`);
+    process.exit(EXIT_USAGE);
+  }
+  if (cmd === "-h" || cmd === "--help" || cmd === "help") {
+    console.log(TOP_HELP);
+    process.exit(EXIT_OK);
+  }
+  const def = SUBCOMMANDS[cmd];
+  if (!def) {
+    console.error(`错误：未知子命令 ${JSON.stringify(cmd)}\n\n${TOP_HELP}`);
+    process.exit(EXIT_USAGE);
+  }
+  if (cmd === "-h") process.exit(EXIT_OK);
+
+  const { opts } = parse(def.spec, argv.slice(1));
+  if (def.noAuth) {
+    process.exit(await def.run(opts));
+  }
+
+  const cfg = loadConfig(CONFIG_PATH, CONFIG_KEYS);
+  const [tokenRaw] = resolveValue(opts.token, cfg.token, "GITEE_TOKEN", "");
+  const token = String(tokenRaw || "").trim();
+  if (!token) {
+    console.error("错误：未设置 Gitee 私人令牌，请先执行：gitee set token 你的令牌"
+      + "（或 export GITEE_TOKEN=你的令牌）");
+    process.exit(EXIT_AUTH);
+  }
+  const [apiRaw] = resolveValue(opts.api, cfg.api, "GITEE_API", DEFAULT_API);
+  const api = apiRaw.replace(/\/+$/, "");
+  const [proxy] = resolveValue(opts.proxy, cfg.proxy, "GITEE_PROXY", null);
+  const [timeout] = resolveValue(opts.timeout, cfg.timeout, null, DEFAULT_TIMEOUT);
+  const client = new Client(token, api, proxy, timeout);
+  try {
+    process.exit(await def.run(client, opts));
+  } catch (e) {
+    if (e instanceof GiteeError) {
+      console.error(`错误：${e.message}`);
+      process.exit(EXIT_API);
+    }
+    console.error(`错误：${e.message}`);
+    process.exit(EXIT_API);
+  }
+}
+
+main().catch((e) => {
+  console.error(`错误：${e.message}`);
+  process.exit(EXIT_API);
+});

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.3.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"
+  }
+}