@leeguoo/zentao-mcp 0.4.1 → 0.5.1

package/src/index.js

@@ -1,475 +1,71 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-
-function parseCliArgs(argv) {
-  const args = {};
-  for (let i = 0; i < argv.length; i += 1) {
-    const raw = argv[i];
-    if (!raw.startsWith("--")) continue;
-    const [flag, inlineValue] = raw.split("=", 2);
-    const key = flag.replace(/^--/, "");
-    if (inlineValue !== undefined) {
-      args[key] = inlineValue;
-      continue;
-    }
-    const next = argv[i + 1];
-    if (next && !next.startsWith("--")) {
-      args[key] = next;
-      i += 1;
-      continue;
-    }
-    args[key] = true;
-  }
-  return args;
-}
-
-function getOption(cliArgs, envName, cliName) {
-  if (cliArgs[cliName]) return cliArgs[cliName];
-  const envValue = process.env[envName];
-  if (envValue) return envValue;
-  return null;
-}
-
-function normalizeBaseUrl(url) {
-  return url.replace(/\/+$/, "");
-}
-
-function toInt(value, fallback) {
-  if (value === undefined || value === null || value === "") return fallback;
-  const parsed = Number(value);
-  return Number.isNaN(parsed) ? fallback : parsed;
+import process from "node:process";
+import { extractCommand, hasHelpFlag } from "./cli/args.js";
+import { printRootHelp } from "./cli/help.js";
+import { runSelfTest } from "./commands/selftest.js";
+import { runRelease } from "./commands/release.js";
+import { runProducts } from "./commands/products.js";
+import { runBugs } from "./commands/bugs.js";
+import { runBug } from "./commands/bug.js";
+import { runLogin } from "./commands/login.js";
+import { runWhoami } from "./commands/whoami.js";
+
+const argv = process.argv.slice(2);
+const { command, argv: argvWithoutCommand } = extractCommand(argv);
+
+function exitWithError(error) {
+  const message = error?.message || String(error);
+  process.stderr.write(`${message}\n`);
+  process.exit(error?.exitCode || 1);
 }
 
-function normalizeResult(payload) {
-  return { status: 1, msg: "success", result: payload };
-}
-
-function normalizeError(message, payload) {
-  return { status: 0, msg: message || "error", result: payload ?? [] };
-}
-
-function normalizeAccountValue(value) {
-  return String(value || "").trim().toLowerCase();
-}
-
-function extractAccounts(value) {
-  if (value === undefined || value === null) return [];
-  if (typeof value === "string" || typeof value === "number") {
-    const normalized = normalizeAccountValue(value);
-    return normalized ? [normalized] : [];
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((item) => extractAccounts(item));
-  }
-  if (typeof value === "object") {
-    if (value.account) return extractAccounts(value.account);
-    if (value.user) return extractAccounts(value.user);
-    if (value.name) return extractAccounts(value.name);
-    if (value.realname) return extractAccounts(value.realname);
-    return [];
+try {
+  if (!command || hasHelpFlag(argv)) {
+    printRootHelp();
+    process.exit(0);
   }
-  return [];
-}
-
-function matchesAccount(value, matchAccount) {
-  const candidates = extractAccounts(value);
-  return candidates.includes(matchAccount);
-}
 
-class ZentaoClient {
-  constructor({ baseUrl, account, password }) {
-    this.baseUrl = normalizeBaseUrl(baseUrl);
-    this.account = account;
-    this.password = password;
-    this.token = null;
+  if (command === "self-test") {
+    await runSelfTest({ argv: argvWithoutCommand, env: process.env });
+    process.exit(0);
   }
 
-  async ensureToken() {
-    if (this.token) return;
-    this.token = await this.getToken();
+  if (command === "release") {
+    await runRelease({ argv: argvWithoutCommand, env: process.env });
+    process.exit(0);
   }
 
-  async getToken() {
-    const url = `${this.baseUrl}/api.php/v1/tokens`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        account: this.account,
-        password: this.password,
-      }),
-    });
-
-    const text = await res.text();
-    let json;
-    try {
-      json = JSON.parse(text);
-    } catch (error) {
-      throw new Error(`Token response parse failed: ${text.slice(0, 200)}`);
-    }
-
-    if (json.error) {
-      throw new Error(`Token request failed: ${json.error}`);
-    }
-
-    if (!json.token) {
-      throw new Error(`Token missing in response: ${text.slice(0, 200)}`);
-    }
-
-    return json.token;
+  if (command === "login") {
+    await runLogin({ argv: argvWithoutCommand, env: process.env });
+    process.exit(0);
   }
 
-  async request({ method, path, query = {}, body }) {
-    await this.ensureToken();
-
-    const url = new URL(`${this.baseUrl}${path}`);
-    Object.entries(query).forEach(([key, value]) => {
-      if (value === undefined || value === null) return;
-      url.searchParams.set(key, String(value));
-    });
-
-    const headers = {
-      Token: this.token,
-    };
-
-    const options = { method, headers };
-
-    if (body !== undefined) {
-      headers["Content-Type"] = "application/json";
-      options.body = JSON.stringify(body);
-    }
-
-    const res = await fetch(url, options);
-    const text = await res.text();
-    let json;
-    try {
-      json = JSON.parse(text);
-    } catch (error) {
-      throw new Error(`Response parse failed: ${text.slice(0, 200)}`);
-    }
-
-    return json;
+  if (command === "whoami") {
+    await runWhoami({ argv: argvWithoutCommand, env: process.env });
+    process.exit(0);
   }
 
-  async listProducts({ page, limit }) {
-    const payload = await this.request({
-      method: "GET",
-      path: "/api.php/v1/products",
-      query: {
-        page: toInt(page, 1),
-        limit: toInt(limit, 1000),
-      },
-    });
-
-    if (payload.error) return normalizeError(payload.error, payload);
-    return normalizeResult(payload);
+  if (command === "products") {
+    await runProducts({ argv: argvWithoutCommand, env: process.env });
+    process.exit(0);
   }
 
-  async listBugs({ product, page, limit }) {
-    if (!product) throw new Error("product is required");
-
-    const payload = await this.request({
-      method: "GET",
-      path: "/api.php/v1/bugs",
-      query: {
-        product,
-        page: toInt(page, 1),
-        limit: toInt(limit, 20),
-      },
-    });
-
-    if (payload.error) return normalizeError(payload.error, payload);
-    return normalizeResult(payload);
+  if (command === "bugs") {
+    await runBugs({ argv: argvWithoutCommand, env: process.env });
+    process.exit(0);
   }
 
-  async getBug({ id }) {
-    if (!id) throw new Error("id is required");
-
-    const payload = await this.request({
-      method: "GET",
-      path: `/api.php/v1/bugs/${id}`,
-    });
-
-    if (payload.error) return normalizeError(payload.error, payload);
-    return normalizeResult(payload);
+  if (command === "bug") {
+    await runBug({ argv: argvWithoutCommand, env: process.env });
+    process.exit(0);
   }
 
-  async fetchAllBugsForProduct({ product, perPage, maxItems }) {
-    const bugs = [];
-    let page = 1;
-    let total = null;
-    const pageSize = toInt(perPage, 100);
-    const cap = toInt(maxItems, 0);
-
-    while (true) {
-      const payload = await this.request({
-        method: "GET",
-        path: "/api.php/v1/bugs",
-        query: {
-          product,
-          page,
-          limit: pageSize,
-        },
-      });
-
-      if (payload.error) {
-        throw new Error(payload.error);
-      }
-
-      const pageBugs = Array.isArray(payload.bugs) ? payload.bugs : [];
-      total = payload.total ?? total;
-      for (const bug of pageBugs) {
-        bugs.push(bug);
-        if (cap > 0 && bugs.length >= cap) {
-          return { bugs, total };
-        }
-      }
-
-      if (total !== null && payload.limit) {
-        if (page * payload.limit >= total) break;
-      } else if (pageBugs.length < pageSize) {
-        break;
-      }
-
-      page += 1;
-    }
-
-    return { bugs, total };
+  if (command === "help") {
+    printRootHelp();
+    process.exit(0);
   }
 
-  async bugsMine({
-    account,
-    scope,
-    status,
-    productIds,
-    includeZero,
-    perPage,
-    maxItems,
-    includeDetails,
-  }) {
-    const matchAccount = normalizeAccountValue(account || this.account);
-    const targetScope = (scope || "assigned").toLowerCase();
-    const rawStatus = status ?? "active";
-    const statusList = Array.isArray(rawStatus)
-      ? rawStatus
-      : String(rawStatus).split(/[|,]/);
-    const statusSet = new Set(
-      statusList.map((item) => String(item).trim().toLowerCase()).filter(Boolean)
-    );
-    const allowAllStatus = statusSet.has("all") || statusSet.size === 0;
-
-    const productsResponse = await this.listProducts({ page: 1, limit: 1000 });
-    if (productsResponse.status !== 1) return productsResponse;
-    const products = productsResponse.result.products || [];
-
-    const productSet = Array.isArray(productIds) && productIds.length
-      ? new Set(productIds.map((id) => Number(id)))
-      : null;
-
-    const rows = [];
-    const bugs = [];
-    let totalMatches = 0;
-    const maxCollect = toInt(maxItems, 200);
-
-    for (const product of products) {
-      if (productSet && !productSet.has(Number(product.id))) continue;
-      const { bugs: productBugs } = await this.fetchAllBugsForProduct({
-        product: product.id,
-        perPage,
-      });
-
-      const matches = productBugs.filter((bug) => {
-        if (!allowAllStatus) {
-          const bugStatus = String(bug.status || "").trim().toLowerCase();
-          if (!statusSet.has(bugStatus)) return false;
-        }
-        const assigned = matchesAccount(bug.assignedTo, matchAccount);
-        const opened = matchesAccount(bug.openedBy, matchAccount);
-        const resolved = matchesAccount(bug.resolvedBy, matchAccount);
-        if (targetScope === "assigned") return assigned;
-        if (targetScope === "opened") return opened;
-        if (targetScope === "resolved") return resolved;
-        return assigned || opened || resolved;
-      });
-
-      if (!includeZero && matches.length === 0) continue;
-      totalMatches += matches.length;
-
-      rows.push({
-        id: product.id,
-        name: product.name,
-        totalBugs: toInt(product.totalBugs, 0),
-        myBugs: matches.length,
-      });
-
-      if (includeDetails && bugs.length < maxCollect) {
-        for (const bug of matches) {
-          if (bugs.length >= maxCollect) break;
-          bugs.push({
-            id: bug.id,
-            title: bug.title,
-            product: bug.product,
-            status: bug.status,
-            pri: bug.pri,
-            severity: bug.severity,
-            assignedTo: bug.assignedTo,
-            openedBy: bug.openedBy,
-            resolvedBy: bug.resolvedBy,
-            openedDate: bug.openedDate,
-          });
-        }
-      }
-    }
-
-    return normalizeResult({
-      account: matchAccount,
-      scope: targetScope,
-      status: allowAllStatus ? "all" : Array.from(statusSet),
-      total: totalMatches,
-      products: rows,
-      bugs: includeDetails ? bugs : [],
-    });
-  }
-}
-
-function createClient() {
-  const cliArgs = parseCliArgs(process.argv.slice(2));
-  const baseUrl = getOption(cliArgs, "ZENTAO_URL", "zentao-url");
-  const account = getOption(cliArgs, "ZENTAO_ACCOUNT", "zentao-account");
-  const password = getOption(cliArgs, "ZENTAO_PASSWORD", "zentao-password");
-
-  if (!baseUrl) throw new Error("Missing ZENTAO_URL or --zentao-url");
-  if (!account) throw new Error("Missing ZENTAO_ACCOUNT or --zentao-account");
-  if (!password) throw new Error("Missing ZENTAO_PASSWORD or --zentao-password");
-  return new ZentaoClient({ baseUrl, account, password });
-}
-
-let client;
-function getClient() {
-  if (!client) client = createClient();
-  return client;
+  throw new Error(`Unknown subcommand: ${command}`);
+} catch (error) {
+  exitWithError(error);
 }
-
-const server = new Server(
-  {
-    name: "zentao-mcp",
-    version: "0.4.1",
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-const tools = [
-  {
-    name: "zentao_products_list",
-    description: "List all products from ZenTao. Use this to get product IDs before querying bugs. Returns product information including ID, name, and bug counts.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        page: { type: "integer", description: "Page number (default 1)." },
-        limit: { type: "integer", description: "Page size (default 1000)." },
-      },
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "zentao_bugs_list",
-    description: "List bugs (缺陷/问题) for a specific product in ZenTao. Use this when user asks to 'see bugs', 'view bugs', 'show bugs', '看bug', '查看bug', '显示bug', or wants to check issues for a product. Requires product ID which can be obtained from zentao_products_list.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        product: { type: "integer", description: "Product ID (required). Get this from zentao_products_list first." },
-        page: { type: "integer", description: "Page number (default 1)." },
-        limit: { type: "integer", description: "Page size (default 20)." },
-      },
-      required: ["product"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "zentao_bug_get",
-    description: "Get bug details (获取Bug详情) by bug ID.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "integer", description: "Bug ID (required)." },
-      },
-      required: ["id"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "zentao_bugs_mine",
-    description: "List my bugs (我的Bug) by assignment or creator. Default scope is assigned. Use when user asks for 'my bugs', '我的bug', '分配给我', or personal bug list.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        account: { type: "string", description: "Account to match (default: login account)." },
-        scope: {
-          type: "string",
-          description: "Filter scope: assigned|opened|resolved|all (default assigned).",
-        },
-        status: {
-          type: ["string", "array"],
-          description: "Status filter: active|resolved|closed|all (default active).",
-        },
-        productIds: {
-          type: "array",
-          items: { type: "integer" },
-          description: "Optional product IDs to limit search.",
-        },
-        includeZero: { type: "boolean", description: "Include products with zero matches (default false)." },
-        perPage: { type: "integer", description: "Page size when scanning products (default 100)." },
-        maxItems: { type: "integer", description: "Max bug items to return (default 200)." },
-        includeDetails: { type: "boolean", description: "Include bug details list (default false)." },
-      },
-      additionalProperties: false,
-    },
-  },
-];
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const args = request.params.arguments || {};
-  try {
-    const api = getClient();
-    let result;
-    switch (request.params.name) {
-      case "zentao_products_list":
-        result = await api.listProducts(args);
-        break;
-      case "zentao_bugs_list":
-        result = await api.listBugs(args);
-        break;
-      case "zentao_bug_get":
-        result = await api.getBug(args);
-        break;
-      case "zentao_bugs_mine":
-        result = await api.bugsMine(args);
-        break;
-      default:
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
-        };
-    }
-
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-    };
-  } catch (error) {
-    return {
-      isError: true,
-      content: [{ type: "text", text: error.message }],
-    };
-  }
-});
-
-const transport = new StdioServerTransport();
-await server.connect(transport);