@thammarongg/jira-mcp 0.3.0 → 0.5.0

package/dist/index.js

@@ -12,14 +12,62 @@ import { registerUserTools } from "./tools/users.js";
 import { registerMetaTools } from "./tools/meta.js";
 import { registerGenericTools } from "./tools/generic.js";
 import { runInstaller } from "./install.js";
+import { runUpdate } from "./update.js";
+import { runUninstall } from "./uninstall.js";
+import { PACKAGE_VERSION } from "./agents.js";
+import { renderStatus } from "./status.js";
+function helpText() {
+    return `jira-mcp — Jira MCP server and configuration helper
+
+Commands:
+  install              Configure the jira MCP server in one or more agents
+  update               Refresh existing jira entries from their own credentials
+  uninstall            Remove jira entries from selected agents
+  --version, -v        Print the installed version
+  --help, -h           Show this help
+
+With no arguments in a terminal, jira-mcp prints a configuration status card.
+With no arguments over piped stdio, it starts the MCP server.
+`;
+}
+function printHelp() {
+    console.log(helpText());
+}
 async function main() {
-    if (process.argv[2] === "install") {
+    const command = process.argv[2];
+    if (command === "install") {
         await runInstaller(process.argv.slice(3));
         return;
     }
+    if (command === "update") {
+        await runUpdate(process.argv.slice(3));
+        return;
+    }
+    if (command === "uninstall") {
+        await runUninstall(process.argv.slice(3));
+        return;
+    }
+    if (command === "--version" || command === "-v") {
+        console.log(PACKAGE_VERSION);
+        return;
+    }
+    if (command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command !== undefined) {
+        console.error(`Unknown command: ${command}`);
+        console.error(helpText());
+        process.exitCode = 1;
+        return;
+    }
+    if (!command && process.stdin.isTTY) {
+        console.log(await renderStatus());
+        return;
+    }
     const config = loadConfig();
     const client = new JiraClient(config);
-    const server = new McpServer({ name: "jira", version: "0.3.0" });
+    const server = new McpServer({ name: "jira", version: PACKAGE_VERSION });
     registerBoardTools(server, client);
     registerSprintTools(server, client);
     registerEpicTools(server, client);
@@ -34,7 +82,10 @@ async function main() {
 }
 main().catch((err) => {
     const msg = err instanceof Error ? err.message : String(err);
-    const prefix = process.argv[2] === "install" ? "jira-mcp install failed" : "jira-mcp failed to start";
+    const command = process.argv[2];
+    const prefix = command === "install" || command === "update" || command === "uninstall"
+        ? `jira-mcp ${command} failed`
+        : "jira-mcp failed to start";
     console.error(`${prefix}: ${msg}`);
     process.exit(1);
 });

package/dist/install.js

@@ -1,30 +1,5 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { homedir, platform } from "node:os";
-import { dirname, join } from "node:path";
-import * as readline from "node:readline";
-import { fileURLToPath } from "node:url";
-function readPackageName() {
-    try {
-        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-        const parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
-        if (typeof parsed.name === "string" && parsed.name.length > 0)
-            return parsed.name;
-    }
-    catch { }
-    return "@thammarongg/jira-mcp";
-}
-const PKG = readPackageName();
-const claudeDesktopPath = platform() === "darwin"
-    ? join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")
-    : join(homedir(), ".config", "Claude", "claude_desktop_config.json");
-const AGENTS = [
-    { id: "claude-code", label: "Claude Code", path: join(homedir(), ".claude.json"), kind: "mcpServers" },
-    { id: "opencode", label: "OpenCode", path: join(homedir(), ".config", "opencode", "opencode.json"), kind: "opencode" },
-    { id: "codex", label: "Codex", path: join(homedir(), ".codex", "config.toml"), kind: "codex" },
-    { id: "cursor", label: "Cursor", path: join(homedir(), ".cursor", "mcp.json"), kind: "mcpServers" },
-    { id: "claude-desktop", label: "Claude Desktop", path: claudeDesktopPath, kind: "mcpServers" },
-    { id: "gemini-cli", label: "Gemini CLI", path: join(homedir(), ".gemini", "settings.json"), kind: "mcpServers" },
-];
+import { AGENTS, PKG, readAgentEnv, resolveAgents, writeAgentConfig } from "./agents.js";
+import { askPassword, makePrompter } from "./prompt.js";
 function parseFlags(argv) {
     const flags = {};
     for (let i = 0; i < argv.length; i++) {
@@ -99,7 +74,7 @@ Usage:
 
 Options:
   --agents <list>    Comma-separated agent ids or 'all': ${AGENTS.map((a) => a.id).join(", ")}
-  --base-url <url>   Jira base URL (required)
+  --base-url <url>   Jira base URL (required unless reusing an existing entry)
   --email <email>    Jira Cloud email (with --token)
   --username <user>  Jira Data Center username (with --token or --password)
   --token <token>    API token / PAT
@@ -108,154 +83,43 @@ Options:
   -h, --help         Show this help
 `);
 }
-function makePrompter() {
-    const queue = [];
-    const waiters = [];
-    let closed = false;
-    let suspended = false;
-    let rl = null;
-    const attach = (r) => {
-        r.on("line", (line) => {
-            const waiter = waiters.shift();
-            if (waiter)
-                waiter(line);
-            else
-                queue.push(line);
-        });
-        r.on("close", () => {
-            if (suspended)
-                return;
-            closed = true;
-            while (waiters.length > 0)
-                waiters.shift()("");
-        });
-    };
-    const start = () => {
-        rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-            terminal: process.stdin.isTTY === true,
-        });
-        attach(rl);
-    };
-    start();
-    const prompter = {
-        get closed() {
-            return closed;
-        },
-        ask(question) {
-            process.stdout.write(question);
-            const queued = queue.shift();
-            if (queued !== undefined)
-                return Promise.resolve(queued);
-            if (closed)
-                return Promise.resolve("");
-            return new Promise((resolve) => waiters.push(resolve));
-        },
-        close() {
-            suspended = false;
-            closed = true;
-            while (waiters.length > 0)
-                waiters.shift()("");
-            rl?.close();
-            rl = null;
-        },
-        suspend() {
-            suspended = true;
-            rl?.close();
-            rl = null;
-        },
-        resume() {
-            suspended = false;
-            if (rl === null)
-                start();
-        },
-        tryQueued() {
-            return queue.shift();
-        },
-    };
-    return prompter;
-}
-function askPassword(p, promptText) {
-    const stdin = process.stdin;
-    if (typeof stdin.setRawMode !== "function") {
-        return p.ask(`${promptText} (no echo available) `).then((v) => v.trim());
-    }
-    const queued = p.tryQueued();
-    if (queued !== undefined) {
-        process.stdout.write(promptText);
-        return Promise.resolve(queued.trim());
-    }
-    return new Promise((resolve, reject) => {
-        let value = "";
-        let finished = false;
-        const cleanup = () => {
-            if (finished)
-                return;
-            finished = true;
-            stdin.removeListener("data", onData);
-            stdin.removeListener("end", onEnd);
-            stdin.removeListener("close", onClose);
-            stdin.setRawMode(false);
-        };
-        const finish = (v) => {
-            cleanup();
-            p.resume();
-            if (v === null)
-                reject(new Error("input closed while reading password"));
-            else {
-                process.stdout.write("\n");
-                resolve(v.trim());
-            }
-        };
-        const onData = (buf) => {
-            for (const ch of buf.toString("utf8")) {
-                if (ch === "\r" || ch === "\n") {
-                    finish(value);
-                    return;
-                }
-                if (ch === "\x03") {
-                    cleanup();
-                    p.resume();
-                    process.exit(130);
-                }
-                if (ch === "\x04") {
-                    finish("");
-                    return;
-                }
-                if (ch === "\u007f" || ch === "\b") {
-                    if (value.length > 0) {
-                        value = value.slice(0, -1);
-                        process.stdout.write("\b \b");
-                    }
-                }
-                else if (ch >= " ") {
-                    value += ch;
-                    process.stdout.write("*");
-                }
-            }
-        };
-        const onEnd = () => finish(null);
-        const onClose = () => finish(null);
-        p.suspend();
-        process.stdout.write(promptText);
-        stdin.setRawMode(true);
-        stdin.resume();
-        stdin.on("data", onData);
-        stdin.on("end", onEnd);
-        stdin.on("close", onClose);
-    });
-}
 export async function runInstaller(argv) {
     const flags = parseFlags(argv);
     validateCredentialFlags(flags);
-    const hasCredentials = (flags.baseUrl && flags.email && flags.token) ||
-        (flags.baseUrl && flags.username && (flags.token || flags.password));
+    const hasCredentials = Boolean((flags.baseUrl && flags.email && flags.token) ||
+        (flags.baseUrl && flags.username && (flags.token || flags.password)));
     const needsPrompts = !flags.agents || !hasCredentials || !flags.yes;
     const p = needsPrompts ? makePrompter() : undefined;
     try {
         const selected = flags.agents ? resolveAgents(flags.agents) : await promptSelection(p);
-        const env = hasCredentials ? buildEnvFromFlags(flags) : await promptCredentials(p);
+        let env;
+        if (hasCredentials) {
+            env = buildEnvFromFlags(flags);
+        }
+        else {
+            const reusable = findReusableCredentials(selected);
+            if (reusable) {
+                const summary = credentialSummary(reusable.env);
+                console.log(`\nFound existing jira credentials in ${reusable.agent.label}: ${summary}`);
+                if (flags.yes) {
+                    console.log(`Using existing credentials from ${reusable.agent.label}.`);
+                    env = reusable.env;
+                }
+                else {
+                    const answer = (await p.ask(`Reuse existing credentials for ${summary}? [Y/n] `)).trim().toLowerCase();
+                    if (answer === "" || answer === "y" || answer === "yes")
+                        env = reusable.env;
+                    else
+                        env = await promptCredentials(p);
+                }
+            }
+            else {
+                if (flags.yes) {
+                    throw new Error("No existing Jira credentials found; provide credential flags or run install interactively");
+                }
+                env = await promptCredentials(p);
+            }
+        }
         console.log("\nWill configure the jira MCP server in:");
         for (const agent of selected)
             console.log(`  - ${agent.label.padEnd(15)} ${agent.path}`);
@@ -290,20 +154,20 @@ export async function runInstaller(argv) {
         p?.close();
     }
 }
-function resolveAgents(spec) {
-    const norm = spec.trim().toLowerCase();
-    if (norm === "all" || norm === "a")
-        return [...AGENTS];
-    const ids = norm.split(/[,\s]+/).filter(Boolean);
-    const selected = ids.map((id) => {
-        const agent = /^\d+$/.test(id) ? AGENTS[Number(id) - 1] : AGENTS.find((a) => a.id === id);
-        if (!agent)
-            throw new Error(`Unknown agent '${id}'. Valid: ${AGENTS.map((a, i) => `${i + 1}/${a.id}`).join(", ")} or all`);
-        return agent;
-    });
-    if (selected.length === 0)
-        throw new Error("No agents selected");
-    return selected;
+function findReusableCredentials(selected) {
+    for (const agent of AGENTS) {
+        if (!selected.includes(agent))
+            continue;
+        const env = readAgentEnv(agent);
+        if (env)
+            return { agent, env };
+    }
+    return undefined;
+}
+function credentialSummary(env) {
+    const baseUrl = env.JIRA_BASE_URL ?? "unknown URL";
+    const account = env.JIRA_EMAIL ?? env.JIRA_USERNAME ?? "unknown account";
+    return `${baseUrl} (${account})`;
 }
 function buildEnvFromFlags(flags) {
     const env = { JIRA_BASE_URL: flags.baseUrl };
@@ -364,201 +228,3 @@ async function promptCredentials(p) {
     }
     return env;
 }
-function writeAgentConfig(agent, env) {
-    if (agent.kind === "codex")
-        return upsertCodex(agent.path, env);
-    if (agent.kind === "opencode") {
-        const jsonc = agent.path.replace(/\.json$/, ".jsonc");
-        if (existsSync(jsonc)) {
-            console.log(`  ! ${jsonc} exists — skipping automatic opencode write (JSONC may contain comments); merge the jira entry manually`);
-            return "skipped";
-        }
-        return mergeJsonFile(agent.path, (obj) => {
-            const mcp = (obj.mcp ??= {});
-            reportEnvChanges(envOf(mcp.jira), env, agent.path);
-            mcp.jira = {
-                type: "local",
-                command: ["npx", "-y", PKG],
-                environment: env,
-                enabled: true,
-            };
-        });
-    }
-    return mergeJsonFile(agent.path, (obj) => {
-        const mcpServers = (obj.mcpServers ??= {});
-        reportEnvChanges(envOf(mcpServers.jira), env, agent.path);
-        mcpServers.jira = { command: "npx", args: ["-y", PKG], env };
-    });
-}
-function envOf(entry) {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-        return undefined;
-    const e = entry.env ?? entry.environment;
-    if (!e || typeof e !== "object" || Array.isArray(e))
-        return undefined;
-    return e;
-}
-function reportEnvChanges(oldEnv, newEnv, path) {
-    if (!oldEnv)
-        return;
-    const replaced = Object.keys(newEnv).filter((k) => oldEnv[k] !== newEnv[k]);
-    const removed = Object.keys(oldEnv).filter((k) => !(k in newEnv));
-    if (replaced.length > 0)
-        console.log(`  ! ${path}: existing jira entry will be replaced — env vars changed: ${replaced.join(", ")}`);
-    if (removed.length > 0)
-        console.log(`  ! ${path}: existing jira entry will be replaced — env vars removed: ${removed.join(", ")}`);
-}
-function fileStamp(path) {
-    const s = statSync(path);
-    return { mtimeMs: s.mtimeMs, size: s.size };
-}
-function assertUnchanged(path, before) {
-    const after = statSync(path);
-    if (after.mtimeMs !== before.mtimeMs || after.size !== before.size) {
-        throw new Error("changed while installing — close running agents and retry");
-    }
-}
-function atomicWrite(path, content) {
-    const tmp = `${path}.tmp-${process.pid}`;
-    writeFileSync(tmp, content);
-    renameSync(tmp, path);
-}
-function mergeJsonFile(path, mutate) {
-    const existed = existsSync(path);
-    let stamp;
-    let obj = {};
-    if (existed) {
-        stamp = fileStamp(path);
-        const raw = readFileSync(path, "utf8");
-        let parsed;
-        try {
-            parsed = raw.trim() ? JSON.parse(raw) : {};
-        }
-        catch {
-            parsed = undefined;
-        }
-        if (parsed === undefined || typeof parsed !== "object" || Array.isArray(parsed)) {
-            console.log(`  ! ${path} is not a JSON object — backing up to ${path}.bak and starting fresh`);
-        }
-        else {
-            obj = parsed;
-        }
-    }
-    mutate(obj);
-    mkdirSync(dirname(path), { recursive: true });
-    if (existed) {
-        assertUnchanged(path, stamp);
-        copyFileSync(path, `${path}.bak`);
-    }
-    atomicWrite(path, JSON.stringify(obj, null, 2) + "\n");
-    return existed ? "updated" : "created";
-}
-function tomlStr(v) {
-    let out = "";
-    for (const ch of v) {
-        const code = ch.codePointAt(0);
-        if (ch === "\\")
-            out += "\\\\";
-        else if (ch === '"')
-            out += '\\"';
-        else if (ch === "\n")
-            out += "\\n";
-        else if (ch === "\t")
-            out += "\\t";
-        else if (ch === "\r")
-            out += "\\r";
-        else if (code < 0x20)
-            out += `\\u${code.toString(16).toUpperCase().padStart(4, "0")}`;
-        else
-            out += ch;
-    }
-    return `"${out}"`;
-}
-const JIRA_HEADER = /^\s*\[mcp_servers\.jira\](\s+#.*)?$/;
-function parseTomlEnv(lines, start) {
-    let end = lines.length;
-    for (let i = start + 1; i < lines.length; i++) {
-        if (/^\s*\[/.test(lines[i])) {
-            end = i;
-            break;
-        }
-    }
-    for (let i = start + 1; i < end; i++) {
-        const m = lines[i].match(/^\s*env\s*=\s*\{(.*)\}\s*$/);
-        if (!m)
-            continue;
-        const out = {};
-        for (const part of m[1].split(",")) {
-            const eq = part.indexOf("=");
-            if (eq < 0)
-                continue;
-            const k = part.slice(0, eq).trim();
-            let v = part.slice(eq + 1).trim();
-            if (v.length >= 2 && v.startsWith('"') && v.endsWith('"'))
-                v = v.slice(1, -1);
-            if (k)
-                out[k] = v;
-        }
-        return out;
-    }
-    return undefined;
-}
-function upsertCodex(path, env) {
-    const block = [
-        "[mcp_servers.jira]",
-        'command = "npx"',
-        `args = ["-y", ${tomlStr(PKG)}]`,
-        `env = { ${Object.entries(env)
-            .map(([k, v]) => `${k} = ${tomlStr(v)}`)
-            .join(", ")} }`,
-    ];
-    if (!existsSync(path)) {
-        mkdirSync(dirname(path), { recursive: true });
-        atomicWrite(path, block.join("\n") + "\n");
-        return "created";
-    }
-    const stamp = fileStamp(path);
-    const raw = readFileSync(path, "utf8");
-    const eol = raw.includes("\r\n") ? "\r\n" : "\n";
-    const lines = raw.split("\n").map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l));
-    const starts = [];
-    for (let i = 0; i < lines.length; i++) {
-        if (JIRA_HEADER.test(lines[i]))
-            starts.push(i);
-    }
-    let content;
-    if (starts.length === 0) {
-        content = raw.replace(/\s*$/, "") + eol + eol + block.join(eol) + eol;
-    }
-    else {
-        const remove = new Set();
-        for (const start of starts) {
-            let end = lines.length;
-            for (let i = start + 1; i < lines.length; i++) {
-                if (/^\s*\[/.test(lines[i])) {
-                    end = i;
-                    break;
-                }
-            }
-            for (let i = start; i < end; i++)
-                remove.add(i);
-        }
-        const kept = lines.filter((_, i) => !remove.has(i));
-        let insertIdx = 0;
-        for (let i = 0; i < starts[0]; i++)
-            if (!remove.has(i))
-                insertIdx++;
-        kept.splice(insertIdx, 0, ...block);
-        const after = insertIdx + block.length;
-        if (after < kept.length && kept[after].trim() !== "")
-            kept.splice(after, 0, "");
-        content = kept.join(eol);
-        if (!content.endsWith(eol))
-            content += eol;
-    }
-    reportEnvChanges(starts.length > 0 ? parseTomlEnv(lines, starts[0]) : undefined, env, path);
-    assertUnchanged(path, stamp);
-    copyFileSync(path, `${path}.bak`);
-    atomicWrite(path, content);
-    return "updated";
-}

package/dist/prompt.js

@@ -0,0 +1,139 @@
+import * as readline from "node:readline";
+export function makePrompter() {
+    const queue = [];
+    const waiters = [];
+    let closed = false;
+    let suspended = false;
+    let rl = null;
+    const attach = (r) => {
+        r.on("line", (line) => {
+            const waiter = waiters.shift();
+            if (waiter)
+                waiter(line);
+            else
+                queue.push(line);
+        });
+        r.on("close", () => {
+            if (suspended)
+                return;
+            closed = true;
+            while (waiters.length > 0)
+                waiters.shift()("");
+        });
+    };
+    const start = () => {
+        rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: process.stdin.isTTY === true,
+        });
+        attach(rl);
+    };
+    start();
+    const prompter = {
+        get closed() {
+            return closed;
+        },
+        ask(question) {
+            process.stdout.write(question);
+            const queued = queue.shift();
+            if (queued !== undefined)
+                return Promise.resolve(queued);
+            if (closed)
+                return Promise.resolve("");
+            return new Promise((resolve) => waiters.push(resolve));
+        },
+        close() {
+            suspended = false;
+            closed = true;
+            while (waiters.length > 0)
+                waiters.shift()("");
+            rl?.close();
+            rl = null;
+        },
+        suspend() {
+            suspended = true;
+            rl?.close();
+            rl = null;
+        },
+        resume() {
+            suspended = false;
+            if (rl === null)
+                start();
+        },
+        tryQueued() {
+            return queue.shift();
+        },
+    };
+    return prompter;
+}
+export function askPassword(p, promptText) {
+    const stdin = process.stdin;
+    if (typeof stdin.setRawMode !== "function") {
+        return p.ask(`${promptText} (no echo available) `).then((v) => v.trim());
+    }
+    const queued = p.tryQueued();
+    if (queued !== undefined) {
+        process.stdout.write(promptText);
+        return Promise.resolve(queued.trim());
+    }
+    return new Promise((resolve, reject) => {
+        let value = "";
+        let finished = false;
+        const cleanup = () => {
+            if (finished)
+                return;
+            finished = true;
+            stdin.removeListener("data", onData);
+            stdin.removeListener("end", onEnd);
+            stdin.removeListener("close", onClose);
+            stdin.setRawMode(false);
+        };
+        const finish = (v) => {
+            cleanup();
+            p.resume();
+            if (v === null)
+                reject(new Error("input closed while reading password"));
+            else {
+                process.stdout.write("\n");
+                resolve(v.trim());
+            }
+        };
+        const onData = (buf) => {
+            for (const ch of buf.toString("utf8")) {
+                if (ch === "\r" || ch === "\n") {
+                    finish(value);
+                    return;
+                }
+                if (ch === "\x03") {
+                    cleanup();
+                    p.resume();
+                    process.exit(130);
+                }
+                if (ch === "\x04") {
+                    finish("");
+                    return;
+                }
+                if (ch === "\u007f" || ch === "\b") {
+                    if (value.length > 0) {
+                        value = value.slice(0, -1);
+                        process.stdout.write("\b \b");
+                    }
+                }
+                else if (ch >= " ") {
+                    value += ch;
+                    process.stdout.write("*");
+                }
+            }
+        };
+        const onEnd = () => finish(null);
+        const onClose = () => finish(null);
+        p.suspend();
+        process.stdout.write(promptText);
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+        stdin.on("end", onEnd);
+        stdin.on("close", onClose);
+    });
+}