@leeguoo/zentao-mcp 0.4.1 → 0.5.1

package/src/commands/bugs.js

@@ -0,0 +1,138 @@
+import process from "node:process";
+import { extractCommand, hasHelpFlag, parseCliArgs } from "../cli/args.js";
+import { createClientFromCli } from "../zentao/client.js";
+
+function parseCsvIntegers(value) {
+  if (value === undefined || value === null || value === "") return null;
+  if (Array.isArray(value)) {
+    const nested = value.flatMap((item) => String(item).split(/[,|]/));
+    const parsed = nested.map((item) => Number(item)).filter((n) => Number.isFinite(n));
+    return parsed.length ? parsed : null;
+  }
+  const tokens = String(value)
+    .split(/[,|]/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const parsed = tokens.map((item) => Number(item)).filter((n) => Number.isFinite(n));
+  return parsed.length ? parsed : null;
+}
+
+function printHelp() {
+  process.stdout.write(`zentao bugs <subcommand>\n\n`);
+  process.stdout.write(`Usage:\n`);
+  process.stdout.write(`  zentao bugs list --product <id> [--page N] [--limit N] [--json]\n`);
+  process.stdout.write(`  zentao bugs mine [--scope assigned|opened|resolved|all] [--status active|resolved|closed|all] [--include-details] [--json]\n`);
+}
+
+function formatAccount(value) {
+  if (!value) return "";
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  if (typeof value === "object") return String(value.account || value.name || value.realname || "");
+  return "";
+}
+
+export function formatBugsSimple(bugs) {
+  const rows = [];
+  rows.push(["id", "title", "status", "pri", "severity", "assignedTo"].join("\t"));
+  for (const bug of bugs) {
+    rows.push(
+      [
+        String(bug?.id ?? ""),
+        String(bug?.title ?? ""),
+        String(bug?.status ?? ""),
+        String(bug?.pri ?? ""),
+        String(bug?.severity ?? ""),
+        formatAccount(bug?.assignedTo),
+      ].join("\t")
+    );
+  }
+  return `${rows.join("\n")}\n`;
+}
+
+export function formatBugsMineSimple(result) {
+  const total = result?.total ?? 0;
+  const products = Array.isArray(result?.products) ? result.products : [];
+  const rows = [];
+  rows.push(`total\t${total}`);
+  rows.push(["id", "name", "myBugs", "totalBugs"].join("\t"));
+  for (const product of products) {
+    rows.push(
+      [
+        String(product?.id ?? ""),
+        String(product?.name ?? ""),
+        String(product?.myBugs ?? ""),
+        String(product?.totalBugs ?? ""),
+      ].join("\t")
+    );
+  }
+
+  const bugs = Array.isArray(result?.bugs) ? result.bugs : [];
+  if (bugs.length) {
+    rows.push("");
+    rows.push("bugs");
+    rows.push(formatBugsSimple(bugs).trimEnd());
+  }
+
+  return `${rows.join("\n")}\n`;
+}
+
+export async function runBugs({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printHelp();
+    return;
+  }
+
+  const { command: sub, argv: argvWithoutSub } = extractCommand(argv);
+  const cliArgs = parseCliArgs(argvWithoutSub);
+  const api = createClientFromCli({ argv: argvWithoutSub, env });
+
+  if (sub === "list") {
+    const product = cliArgs.product;
+    if (!product) throw new Error("Missing --product");
+    const result = await api.listBugs({
+      product,
+      page: cliArgs.page,
+      limit: cliArgs.limit,
+    });
+
+    if (cliArgs.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+
+    const bugs = result?.result?.bugs;
+    if (!Array.isArray(bugs)) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+
+    process.stdout.write(formatBugsSimple(bugs));
+    return;
+  }
+
+  if (sub === "mine") {
+    const includeDetails = Boolean(cliArgs["include-details"]);
+    const includeZero = Boolean(cliArgs["include-zero"]);
+    const productIds = parseCsvIntegers(cliArgs["product-ids"]);
+    const result = await api.bugsMine({
+      account: cliArgs.account,
+      scope: cliArgs.scope,
+      status: cliArgs.status,
+      productIds,
+      includeZero,
+      perPage: cliArgs["per-page"],
+      maxItems: cliArgs["max-items"],
+      includeDetails,
+    });
+
+    if (cliArgs.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+
+    process.stdout.write(formatBugsMineSimple(result?.result));
+    return;
+  }
+
+  throw new Error(`Unknown bugs subcommand: ${sub || "(missing)"}`);
+}

package/src/commands/login.js

@@ -0,0 +1,60 @@
+import process from "node:process";
+import readline from "node:readline";
+import { hasHelpFlag, parseCliArgs, getOption } from "../cli/args.js";
+import { saveConfig } from "../config/store.js";
+import { ZentaoClient } from "../zentao/client.js";
+
+function printHelp() {
+  process.stdout.write(`zentao login - save credentials locally\n\n`);
+  process.stdout.write(`Usage:\n`);
+  process.stdout.write(`  zentao login --zentao-url=... --zentao-account=... --zentao-password=... [--yes]\n`);
+  process.stdout.write(`\n`);
+  process.stdout.write(`Notes:\n`);
+  process.stdout.write(`  Credentials are stored as plaintext TOML in your user config directory.\n`);
+}
+
+async function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await new Promise((resolve) => rl.question(question, resolve));
+  } finally {
+    rl.close();
+  }
+}
+
+export async function runLogin({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printHelp();
+    return;
+  }
+
+  const cliArgs = parseCliArgs(argv);
+  const yes = Boolean(cliArgs.yes);
+  let baseUrl = getOption(cliArgs, env, "ZENTAO_URL", "zentao-url");
+  let account = getOption(cliArgs, env, "ZENTAO_ACCOUNT", "zentao-account");
+  let password = getOption(cliArgs, env, "ZENTAO_PASSWORD", "zentao-password");
+
+  if (!baseUrl && !yes) baseUrl = String(await prompt("ZENTAO_URL: ")).trim();
+  if (!account && !yes) account = String(await prompt("ZENTAO_ACCOUNT: ")).trim();
+  if (!password && !yes) password = String(await prompt("ZENTAO_PASSWORD (echoed): ")).trim();
+
+  if (!baseUrl || !account || !password) {
+    throw new Error("Missing credentials. Provide flags/env, or run interactively.");
+  }
+
+  // Verify credentials by requesting a token.
+  const client = new ZentaoClient({ baseUrl, account, password });
+  await client.ensureToken();
+
+  const filePath = saveConfig(
+    {
+      zentaoUrl: baseUrl,
+      zentaoAccount: account,
+      zentaoPassword: password,
+    },
+    { env }
+  );
+
+  process.stdout.write(`Logged in as ${account}\n`);
+  process.stdout.write(`Saved to ${filePath}\n`);
+}

package/src/commands/products.js

@@ -0,0 +1,58 @@
+import process from "node:process";
+import { extractCommand, hasHelpFlag, parseCliArgs } from "../cli/args.js";
+import { createClientFromCli } from "../zentao/client.js";
+
+function printHelp() {
+  process.stdout.write(`zentao products list\n\n`);
+  process.stdout.write(`Usage:\n`);
+  process.stdout.write(`  zentao products list [--page N] [--limit N] [--json]\n`);
+  process.stdout.write(`\n`);
+  process.stdout.write(`Options:\n`);
+  process.stdout.write(`  --json               print full JSON payload\n`);
+}
+
+export function formatProductsSimple(products) {
+  const rows = [];
+  rows.push(["id", "name", "totalBugs", "status"].join("\t"));
+  for (const product of products) {
+    rows.push(
+      [
+        String(product.id ?? ""),
+        String(product.name ?? ""),
+        String(product.totalBugs ?? product.totalBugsCount ?? ""),
+        String(product.status ?? product.productStatus ?? ""),
+      ].join("\t")
+    );
+  }
+  return `${rows.join("\n")}\n`;
+}
+
+export async function runProducts({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printHelp();
+    return;
+  }
+
+  const { command: sub, argv: argvWithoutSub } = extractCommand(argv);
+  if (sub !== "list") throw new Error(`Unknown products subcommand: ${sub || "(missing)"}`);
+
+  const cliArgs = parseCliArgs(argvWithoutSub);
+  const api = createClientFromCli({ argv: argvWithoutSub, env });
+  const result = await api.listProducts({
+    page: cliArgs.page,
+    limit: cliArgs.limit,
+  });
+
+  if (cliArgs.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  const products = result?.result?.products;
+  if (!Array.isArray(products)) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatProductsSimple(products));
+}

package/src/commands/release.js

@@ -0,0 +1,198 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import readline from "node:readline";
+import { spawnSync } from "node:child_process";
+import { extractCommand, hasHelpFlag, parseCliArgs } from "../cli/args.js";
+import { printReleaseHelp } from "../cli/help.js";
+
+function run(cmd, args, { cwd, env, dryRun } = {}) {
+  const printable = [cmd, ...args].join(" ");
+  if (dryRun) {
+    process.stdout.write(`[dry-run] ${printable}\n`);
+    return { status: 0 };
+  }
+  const res = spawnSync(cmd, args, {
+    cwd,
+    env,
+    stdio: "inherit",
+  });
+  if (res.status !== 0) {
+    const error = new Error(`Command failed (${res.status}): ${printable}`);
+    error.exitCode = res.status || 1;
+    throw error;
+  }
+  return res;
+}
+
+function commandExists(name) {
+  if (process.platform === "win32") {
+    const res = spawnSync("where", [name], { stdio: "ignore" });
+    return res.status === 0;
+  }
+  const res = spawnSync("sh", ["-lc", `command -v ${name}`], {
+    stdio: "ignore",
+  });
+  return res.status === 0;
+}
+
+async function confirm(question, { yes }) {
+  if (yes) return true;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(`${question} (y/n) `, (value) => resolve(value));
+    });
+    return String(answer).trim().toLowerCase().startsWith("y");
+  } finally {
+    rl.close();
+  }
+}
+
+function readPackageVersion(repoRoot) {
+  const pkgPath = path.join(repoRoot, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  return String(pkg.version || "0.0.0");
+}
+
+function extractChangelogNotes(repoRoot, version) {
+  const changelogPath = path.join(repoRoot, "CHANGELOG.md");
+  if (!fs.existsSync(changelogPath)) return `Release v${version}`;
+  const text = fs.readFileSync(changelogPath, "utf8");
+  const start = text.match(new RegExp(`^## \\s*\\[?${version.replace(/\./g, "\\.")}\\]?\\s*$`, "m"));
+  if (!start) return `Release v${version}`;
+  const startIndex = start.index ?? 0;
+  const rest = text.slice(startIndex);
+  const next = rest.slice(1).match(/^##\s/m);
+  const endIndex = next ? startIndex + 1 + (next.index ?? 0) : text.length;
+  return text.slice(startIndex, endIndex).trim();
+}
+
+function gitHasUncommittedChanges(repoRoot) {
+  const res = spawnSync("git", ["diff-index", "--quiet", "HEAD", "--"], {
+    cwd: repoRoot,
+    stdio: "ignore",
+  });
+  return res.status !== 0;
+}
+
+function ensureGitRepo(repoRoot) {
+  const res = spawnSync("git", ["rev-parse", "--git-dir"], { cwd: repoRoot, stdio: "ignore" });
+  if (res.status !== 0) {
+    throw new Error("Not a git repo. Please run this command from a git repository.");
+  }
+}
+
+function ensureDependencies() {
+  const missing = [];
+  for (const cmd of ["git", "npm", "gh"]) {
+    if (!commandExists(cmd)) missing.push(cmd);
+  }
+  if (missing.length) {
+    throw new Error(`Missing required tools: ${missing.join(", ")}`);
+  }
+}
+
+export async function runRelease({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printReleaseHelp();
+    return;
+  }
+
+  const { command: versionTypeRaw, argv: argvWithoutVersionType } = extractCommand(argv);
+  const versionType = versionTypeRaw || "patch";
+  const cliArgs = parseCliArgs(argvWithoutVersionType);
+  const repoRoot = process.cwd();
+
+  const dryRun = Boolean(cliArgs["dry-run"]);
+  const yes = Boolean(cliArgs.yes);
+  const skipPush = Boolean(cliArgs["skip-push"]);
+  const skipGithubRelease = Boolean(cliArgs["skip-github-release"]);
+  const skipPublish = Boolean(cliArgs["skip-publish"]);
+
+  if (!new Set(["patch", "minor", "major"]).has(versionType)) {
+    throw new Error(`Invalid version type: ${versionType}`);
+  }
+
+  ensureDependencies();
+  ensureGitRepo(repoRoot);
+
+  if (gitHasUncommittedChanges(repoRoot)) {
+    const ok = await confirm("Warning: uncommitted changes. Continue?", { yes });
+    if (!ok) return;
+  }
+
+  const currentVersion = readPackageVersion(repoRoot);
+  process.stdout.write(`Current version: ${currentVersion}\n`);
+  run("npm", ["version", versionType, "--no-git-tag-version"], { cwd: repoRoot, env, dryRun });
+  const newVersion = readPackageVersion(repoRoot);
+  process.stdout.write(`New version: ${newVersion}\n`);
+
+  run("git", ["add", "package.json"], { cwd: repoRoot, env, dryRun });
+  try {
+    run("git", ["commit", "-m", `chore: bump version to ${newVersion}`], { cwd: repoRoot, env, dryRun });
+  } catch (error) {
+    if (!/nothing to commit/i.test(String(error.message || ""))) throw error;
+  }
+
+  run("git", ["tag", "-a", `v${newVersion}`, "-m", `Release v${newVersion}`], {
+    cwd: repoRoot,
+    env,
+    dryRun,
+  });
+
+  if (!skipPush) {
+    const pushAttempts = [
+      ["push", "origin", "main"],
+      ["push", "origin", "master"],
+      ["push"],
+    ];
+    let pushed = false;
+    for (const args of pushAttempts) {
+      try {
+        run("git", args, { cwd: repoRoot, env, dryRun });
+        pushed = true;
+        break;
+      } catch (error) {
+        if (dryRun) {
+          pushed = true;
+          break;
+        }
+      }
+    }
+    if (!pushed && !dryRun) {
+      throw new Error("Failed to push branch.");
+    }
+    run("git", ["push", "origin", `v${newVersion}`], { cwd: repoRoot, env, dryRun });
+  }
+
+  if (!skipGithubRelease) {
+    const notes = extractChangelogNotes(repoRoot, newVersion);
+    run(
+      "gh",
+      [
+        "release",
+        "create",
+        `v${newVersion}`,
+        "--title",
+        `v${newVersion}`,
+        "--notes",
+        notes,
+        "--latest",
+      ],
+      { cwd: repoRoot, env, dryRun }
+    );
+  }
+
+  if (!skipPublish) {
+    const whoami = spawnSync("npm", ["whoami"], { cwd: repoRoot, stdio: "ignore" });
+    if (whoami.status !== 0) {
+      const ok = await confirm("Warning: not logged into npm. Run npm login now?", { yes });
+      if (!ok) return;
+      run("npm", ["login"], { cwd: repoRoot, env, dryRun });
+    }
+    run("npm", ["publish", "--access", "public"], { cwd: repoRoot, env, dryRun });
+  }
+
+  process.stdout.write(`Release done: v${newVersion}\n`);
+}

package/src/commands/selftest.js

@@ -0,0 +1,52 @@
+import process from "node:process";
+import { getOption, hasHelpFlag, parseCliArgs } from "../cli/args.js";
+import { printSelfTestHelp } from "../cli/help.js";
+import { createClientFromCli } from "../zentao/client.js";
+
+export async function runSelfTest({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printSelfTestHelp();
+    return;
+  }
+
+  const cliArgs = parseCliArgs(argv);
+  const baseUrl = getOption(cliArgs, env, "ZENTAO_URL", "zentao-url");
+  const account = getOption(cliArgs, env, "ZENTAO_ACCOUNT", "zentao-account");
+  const password = getOption(cliArgs, env, "ZENTAO_PASSWORD", "zentao-password");
+  const expectedRaw = cliArgs.expected ?? null;
+  const expected = expectedRaw === null ? null : Number(expectedRaw);
+
+  if (!baseUrl || !account || !password) {
+    throw new Error("Missing ZENTAO_URL/ZENTAO_ACCOUNT/ZENTAO_PASSWORD (or CLI args). ");
+  }
+
+  const api = createClientFromCli({ argv, env });
+  const result = await api.bugsMine({
+    scope: "assigned",
+    status: "active",
+    includeDetails: false,
+  });
+
+  if (result.status !== 1) {
+    const error = new Error(`API error: ${JSON.stringify(result)}`);
+    error.exitCode = 1;
+    throw error;
+  }
+
+  const total = result.result?.total ?? 0;
+  process.stdout.write(`assigned active bugs: ${total}\n`);
+
+  const products = result.result?.products ?? [];
+  if (Array.isArray(products) && products.length) {
+    const summary = products.map((item) => `${item.name}(${item.myBugs})`).join(", ");
+    process.stdout.write(`products: ${summary}\n`);
+  }
+
+  if (Number.isFinite(expected) && expected !== null) {
+    if (total !== expected) {
+      const error = new Error(`Expected ${expected}, got ${total}.`);
+      error.exitCode = 2;
+      throw error;
+    }
+  }
+}

package/src/commands/whoami.js

@@ -0,0 +1,32 @@
+import process from "node:process";
+import { hasHelpFlag } from "../cli/args.js";
+import { loadConfig } from "../config/store.js";
+import { ZentaoClient, createClientFromCli } from "../zentao/client.js";
+
+function printHelp() {
+  process.stdout.write(`zentao whoami - show current account\n\n`);
+  process.stdout.write(`Usage:\n`);
+  process.stdout.write(`  zentao whoami\n`);
+  process.stdout.write(`\n`);
+  process.stdout.write(`Reads credentials from flags/env, falling back to saved login config.\n`);
+}
+
+export async function runWhoami({ argv = [], env = process.env } = {}) {
+  if (hasHelpFlag(argv)) {
+    printHelp();
+    return;
+  }
+
+  const stored = loadConfig({ env }) || null;
+  const client = createClientFromCli({ argv, env });
+
+  // Best-effort verification: ensure token can be fetched.
+  await client.ensureToken();
+
+  const account = client.account;
+  const baseUrl = client.baseUrl;
+  process.stdout.write(`${account}\n`);
+  if (stored && (stored.zentaoUrl || stored.zentaoAccount)) {
+    process.stdout.write(`url: ${baseUrl}\n`);
+  }
+}

package/src/config/store.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+function escapeTomlString(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\"/g, "\\\"");
+}
+
+function unescapeTomlString(value) {
+  return String(value)
+    .replace(/\\n/g, "\n")
+    .replace(/\\\"/g, '"')
+    .replace(/\\\\/g, "\\");
+}
+
+function parseToml(text) {
+  const out = {};
+  const lines = String(text).split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) continue;
+    if (line.startsWith("[")) continue;
+
+    const idx = line.indexOf("=");
+    if (idx === -1) continue;
+
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = unescapeTomlString(value.slice(1, -1));
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+
+    if (key) out[key] = value;
+  }
+  return out;
+}
+
+function toToml(config) {
+  const lines = [];
+  lines.push('# zentao CLI config');
+  lines.push('# WARNING: stored as plaintext');
+  if (config.zentaoUrl) lines.push(`zentaoUrl = "${escapeTomlString(config.zentaoUrl)}"`);
+  if (config.zentaoAccount) lines.push(`zentaoAccount = "${escapeTomlString(config.zentaoAccount)}"`);
+  if (config.zentaoPassword) lines.push(`zentaoPassword = "${escapeTomlString(config.zentaoPassword)}"`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+function getConfigDir(env) {
+  const xdg = env.XDG_CONFIG_HOME;
+  if (xdg) return xdg;
+  const home = os.homedir();
+  return path.join(home, ".config");
+}
+
+export function getConfigPath({ env = process.env } = {}) {
+  return path.join(getConfigDir(env), "zentao", "config.toml");
+}
+
+export function loadConfig({ env = process.env } = {}) {
+  const filePath = getConfigPath({ env });
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const data = parseToml(raw);
+    if (!data || typeof data !== "object") return null;
+    return data;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function saveConfig(config, { env = process.env } = {}) {
+  const filePath = getConfigPath({ env });
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, toToml(config), "utf8");
+  return filePath;
+}