@simplysf/simply-atlassian-mcp 0.2.2

package/README.md

@@ -0,0 +1,129 @@
+# @simplysf/simply-atlassian-mcp
+
+[![NPM](https://img.shields.io/npm/v/@simplysf/simply-atlassian-mcp?label=@simplysf/simply-atlassian-mcp)](https://npmjs.com/@simplysf/simply-atlassian-mcp) [![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://raw.githubusercontent.com/SimplySF/simply-atlassian/main/LICENSE.txt)
+
+A [Model Context Protocol](https://modelcontextprotocol.io/) server that gives an AI agent in
+Claude Desktop, Claude Code, Cursor, or any other MCP client the same Jira and Confluence
+capabilities as the [`@simplysf/simply-atlassian`](../simply-atlassian) CLI: one tool per command,
+calling the same [`@simplysf/simply-atlassian-core`](../simply-atlassian-core) library in-process.
+The agent gets the CLI's credential handling, `dryRun` previews, read-only guard, credential
+redaction, and error messages, and the same raw JSON the CLI prints with `--json`, without a
+process per call.
+
+## Install
+
+```bash
+npm install -g @simplysf/simply-atlassian-mcp
+```
+
+## Configure an MCP client
+
+The server speaks MCP over stdio. Point a client at the binary and give it the connection settings
+the CLI reads — see the [Credentials](https://simplysf.github.io/simply-atlassian/guides/credentials/)
+guide — either as environment variables or as a file. For Claude Desktop, in
+`claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "simply-atlassian": {
+      "command": "simply-atlassian-mcp",
+      "args": ["--env-file", "/home/me/atlassian.env"]
+    }
+  }
+}
+```
+
+For Claude Code:
+
+```sh
+claude mcp add simply-atlassian -- simply-atlassian-mcp --env-file ~/atlassian.env
+```
+
+## Read-only by default
+
+Started without options, the server registers only the read tools. Start it with `--allow-writes`
+to also register the tools that create, update, transition, comment, link, and delete. Even then,
+`ATLASSIAN_READ_ONLY` in the environment refuses every write, exactly as it does for the CLI.
+
+That mirrors the two-credential-file arrangement in
+[Write safety](https://simplysf.github.io/simply-atlassian/guides/write-safety/): give the agent's
+everyday server a read-scoped token, and configure a second server entry with `--allow-writes` and
+a write-capable token only when a person means to let the agent write. A read-scoped token is
+still the only layer that binds; the server-side default just keeps write tools out of the agent's
+normal loop entirely.
+
+With writes allowed:
+
+- every write tool accepts `dryRun: true`, which returns the request that would be sent without
+  sending it;
+- `jira_issue_delete` and `jira_issue_comment_delete` also require `confirm: true`, and so does
+  `confluence_page_delete` with `purge: true`. A call without it is refused before anything is
+  looked up. Trashing a page needs no `confirm`, because it is reversible.
+
+## Tools
+
+| Read tools (always registered) | Write tools (`--allow-writes`)                          |
+| ------------------------------ | ------------------------------------------------------- |
+| `jira_whoami`                  | `jira_issue_create`                                     |
+| `jira_user_search`             | `jira_issue_update`                                     |
+| `jira_user_view`               | `jira_issue_transition`                                 |
+| `jira_open`                    | `jira_issue_delete` (needs `confirm`)                   |
+| `jira_issue_search`            | `jira_issue_comment_add`                                |
+| `jira_issue_view`              | `jira_issue_comment_edit`                               |
+| `jira_issue_history`           | `jira_issue_comment_delete` (needs `confirm`)           |
+| `jira_issue_transitions`       | `jira_issue_link_create`                                |
+| `jira_issue_comment_list`      | `jira_issue_link_delete`                                |
+| `jira_issue_link_list`         | `jira_sprint_add`                                       |
+| `jira_issue_link_types`        | `confluence_page_create`                                |
+| `jira_board_list`              | `confluence_page_update`                                |
+| `jira_sprint_list`             | `confluence_page_delete` (needs `confirm` with `purge`) |
+| `jira_sprint_issues`           | `confluence_page_comment_add`                           |
+| `confluence_open`              |                                                         |
+| `confluence_page_get`          |                                                         |
+| `confluence_page_search`       |                                                         |
+| `confluence_page_children`     |                                                         |
+| `confluence_page_comment_list` |                                                         |
+
+Each tool's inputs are the command's arguments and flags in camel case; see the CLI's
+[command reference](https://simplysf.github.io/simply-atlassian/reference/) for what each does.
+`fields` on the issue tools matters as much here as in the CLI: raw issue payloads are large, and
+an agent pays for every token it reads. The two `open` tools return the URL rather than launching
+a browser.
+
+## Results and errors
+
+A successful call returns what the CLI prints with `--json`, verbatim. A failure returns an error
+result whose text is a JSON object with a stable `code`:
+
+| `code`             | Meaning                                                                           |
+| ------------------ | --------------------------------------------------------------------------------- |
+| `config`           | Missing or contradictory settings, a refused write, bad input. CLI exit code 2.   |
+| `auth`             | The instance rejected the credentials; carries the HTTP `status`. Exit code 3.    |
+| `error`            | Any other failure, including an API error with its `status` and sanitised `body`. |
+| `confirm-required` | A destructive tool was called without `confirm: true`.                            |
+
+The first three carry the same `name`, `message`, and `exitCode` the CLI writes to stderr,
+scrubbed the same way, as described in
+[Scripts and agents](https://simplysf.github.io/simply-atlassian/guides/scripting/).
+
+## Options
+
+```
+simply-atlassian-mcp [--allow-writes] [--env-file <path>]
+```
+
+`--help` prints the options and the full tool list. Because stdout is the protocol stream, it
+prints to stderr.
+
+## Issues
+
+Please report any issues at https://github.com/SimplySF/simply-atlassian/issues
+
+## Contributing
+
+This package is part of the [`@simplysf/simply-atlassian`](https://github.com/SimplySF/simply-atlassian) monorepo. See [CONTRIBUTING.md](CONTRIBUTING.md) for what's specific to this package, and the repo's [root CONTRIBUTING.md](https://github.com/SimplySF/simply-atlassian/blob/main/CONTRIBUTING.md) for repo structure, setup, commit conventions, and how to submit a pull request. Please also read our [Code of Conduct](https://github.com/SimplySF/simply-atlassian/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+Licensed under the [Apache-2.0](https://raw.githubusercontent.com/SimplySF/simply-atlassian/main/LICENSE.txt) license.

package/bin/run.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+// Stdio MCP servers own stdout as the protocol channel, so nothing here (or anywhere under
+// src/) may write to it except the transport. Diagnostics go to stderr.
+import { parseArgs } from 'node:util';
+
+const { values } = parseArgs({
+  options: {
+    'allow-writes': { type: 'boolean', default: false },
+    'env-file': { type: 'string' },
+    help: { type: 'boolean', short: 'h', default: false },
+  },
+  strict: true,
+});
+
+const { selectTools, startServer } = await import('../lib/index.js');
+
+if (values.help) {
+  const list = (tools) => tools.map((tool) => `  ${tool.name.padEnd(30)} ${tool.title}`).join('\n');
+  process.stderr.write(
+    [
+      'Usage: simply-atlassian-mcp [--allow-writes] [--env-file <path>]',
+      '',
+      'Serves Jira and Confluence as MCP tools over stdio, one tool per simply-atlassian CLI',
+      'command, calling the same library in-process. Connection settings come from the',
+      'environment (JIRA_URL, JIRA_USERNAME, JIRA_API_TOKEN, CONFLUENCE_*, ...) or --env-file.',
+      '',
+      '  --allow-writes    Also register the tools that change or delete data (off by default).',
+      '                    ATLASSIAN_READ_ONLY in the environment still refuses every write.',
+      '  --env-file <path> A .env file holding connection settings the environment does not.',
+      '',
+      'Read tools (always registered):',
+      list(selectTools(false)),
+      '',
+      'Write tools (with --allow-writes):',
+      list(selectTools(true).filter((tool) => tool.kind !== 'read')),
+      '',
+    ].join('\n'),
+  );
+  process.exit(0);
+}
+
+try {
+  await startServer({ allowWrites: values['allow-writes'], envFile: values['env-file'] });
+} catch (error) {
+  // A missing or unreadable --env-file is the one failure that can happen before the transport
+  // is up; everything else is reported per tool call.
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(typeof error?.exitCode === 'number' ? error.exitCode : 1);
+}

package/lib/context.d.ts

@@ -0,0 +1,32 @@
+import { type AtlassianConfig, ConfluenceClient, type EnvLike, JiraClient } from '@simplysf/simply-atlassian-core';
+export interface ServerOptions {
+    /**
+     * Register the tools that change or delete data. Off by default, so a server launched
+     * without thinking about it can only read. Even when on, a write is still refused when the
+     * environment carries `ATLASSIAN_READ_ONLY`, exactly as the CLI refuses it.
+     */
+    readonly allowWrites?: boolean;
+    /**
+     * A `.env` file holding connection settings the host did not set. Loaded once, at startup,
+     * with the CLI's precedence: a variable already in the environment wins over the file.
+     */
+    readonly envFile?: string;
+    /** The environment to read settings from. Defaults to this process's; tests pass their own. */
+    readonly env?: EnvLike;
+}
+/**
+ * What every tool handler gets: the environment its settings come from, and clients built from
+ * it on demand. Clients are built per call rather than at startup so a missing or wrong setting
+ * is reported by the tool that needed it — the same moment the CLI would report it — and so a
+ * server configured for only one product still serves that product's tools.
+ */
+export interface ToolContext {
+    readonly env: EnvLike;
+    readonly allowWrites: boolean;
+    jiraConfig(): AtlassianConfig;
+    jira(): JiraClient;
+    confluenceConfig(): AtlassianConfig;
+    confluence(): ConfluenceClient;
+}
+/** Builds the context, loading the env file first so every later lookup sees it. */
+export declare function createContext(options?: ServerOptions): ToolContext;

package/lib/context.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, SimplySF.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import process from 'node:process';
+import { ConfluenceClient, JiraClient, loadEnvFile, resolveConfluenceConfig, resolveJiraConfig, } from '@simplysf/simply-atlassian-core';
+/** Builds the context, loading the env file first so every later lookup sees it. */
+export function createContext(options = {}) {
+    const env = options.env ?? process.env;
+    if (options.envFile !== undefined)
+        loadEnvFile(options.envFile, env);
+    return {
+        env,
+        allowWrites: options.allowWrites ?? false,
+        jiraConfig: () => resolveJiraConfig({}, env),
+        jira: () => new JiraClient(resolveJiraConfig({}, env)),
+        confluenceConfig: () => resolveConfluenceConfig({}, env),
+        confluence: () => new ConfluenceClient(resolveConfluenceConfig({}, env)),
+    };
+}
+//# sourceMappingURL=context.js.map

package/lib/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,OAAO,MAAM,cAAc,CAAC;AACnC,OAAO,EAEL,gBAAgB,EAEhB,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAiCzC,oFAAoF;AACpF,MAAM,UAAU,aAAa,CAAC,UAAyB,EAAE;IACvD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IACvC,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS;QAAE,WAAW,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IAErE,OAAO;QACL,GAAG;QACH,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,KAAK;QACzC,UAAU,EAAE,GAAG,EAAE,CAAC,iBAAiB,CAAC,EAAE,EAAE,GAAG,CAAC;QAC5C,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,UAAU,CAAC,iBAAiB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QACtD,gBAAgB,EAAE,GAAG,EAAE,CAAC,uBAAuB,CAAC,EAAE,EAAE,GAAG,CAAC;QACxD,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,gBAAgB,CAAC,uBAAuB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;KACzE,CAAC;AACJ,CAAC"}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { createContext, type ServerOptions, type ToolContext } from './context.js';
+export { createServer, invokeTool, mapError, selectTools, SERVER_NAME, SERVER_VERSION, startServer, type ToolError, type ToolErrorCode, } from './server.js';
+export { TOOLS, type ToolKind, type ToolSpec } from './tools.js';

package/lib/index.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2026, SimplySF.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Everything exported from this file is this package's public API. The package is a stdio MCP
+// server first (see bin/run.js); the programmatic surface exists so a host process can embed the
+// same server over a transport of its choosing, and so tests can drive it in-memory.
+export { createContext } from './context.js';
+export { createServer, invokeTool, mapError, selectTools, SERVER_NAME, SERVER_VERSION, startServer, } from './server.js';
+export { TOOLS } from './tools.js';
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,8FAA8F;AAC9F,iGAAiG;AACjG,qFAAqF;AACrF,OAAO,EAAE,aAAa,EAAwC,MAAM,cAAc,CAAC;AACnF,OAAO,EACL,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,WAAW,EACX,WAAW,EACX,cAAc,EACd,WAAW,GAGZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,EAAgC,MAAM,YAAY,CAAC"}

package/lib/server.d.ts

@@ -0,0 +1,50 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type ServerOptions, type ToolContext } from './context.js';
+import { type ToolSpec } from './tools.js';
+/** The name this server announces during the MCP `initialize` handshake. */
+export declare const SERVER_NAME = "simply-atlassian";
+/** The version this server announces; always the package version, never a separate constant. */
+export declare const SERVER_VERSION: string;
+/**
+ * Stable, machine-readable failure categories. The first three mirror the CLI's exit codes
+ * (2, 3, and 1); `confirm-required` is this server's own gate.
+ */
+export type ToolErrorCode = 'config' | 'auth' | 'error' | 'confirm-required';
+/** The JSON object an `isError` result carries: the same fields as the CLI's `--json` error line. */
+export interface ToolError {
+    readonly code: ToolErrorCode;
+    readonly name: string;
+    readonly message: string;
+    readonly exitCode: number;
+    /** HTTP status, when the instance answered with one. */
+    readonly status?: number;
+    /** The response body, sanitised the same way the message is, when the instance sent one. */
+    readonly body?: unknown;
+}
+/** Which tools a server with the given options registers. Exported so `--help` can list them. */
+export declare function selectTools(allowWrites: boolean): readonly ToolSpec[];
+/**
+ * Builds the MCP server with its metadata and tools registered, but not yet connected to a
+ * transport. Kept separate from {@link startServer} so tests can attach an in-memory transport
+ * and a host process can embed the server over whatever transport it runs.
+ */
+export declare function createServer(options?: ServerOptions): McpServer;
+/**
+ * Creates the server and serves it over stdio, which is how MCP clients such as Claude Desktop,
+ * Claude Code, and Cursor launch a local server. Resolves once the transport is connected; the
+ * process then stays alive until the client closes the stream.
+ */
+export declare function startServer(options?: ServerOptions): Promise<McpServer>;
+/**
+ * Runs one tool call end to end: the `confirm` gate, the read-only guard, the operation, and
+ * the mapping of a failure onto a tool result. Never throws for an operational failure — those
+ * are `isError` results the agent can read and act on — and only lets a genuine bug propagate.
+ */
+export declare function invokeTool(spec: ToolSpec, context: ToolContext, input: Readonly<Record<string, unknown>>): Promise<CallToolResult>;
+/**
+ * Turns a failure into the same object the CLI writes to stderr under `--json`, with the same
+ * scrubbing: the message and any response body are redacted of credentials and stripped of
+ * control characters before they reach an agent's context.
+ */
+export declare function mapError(error: unknown, context: Pick<ToolContext, 'env'>): ToolError;

package/lib/server.js

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2026, SimplySF.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { createRequire } from 'node:module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { assertWritesAllowed, AuthError, CliError, ConfigError, HttpError, redactSecrets, sanitiseDeep, secretValues, stripControl, } from '@simplysf/simply-atlassian-core';
+import { createContext } from './context.js';
+import { TOOLS } from './tools.js';
+const { version } = createRequire(import.meta.url)('../package.json');
+/** The name this server announces during the MCP `initialize` handshake. */
+export const SERVER_NAME = 'simply-atlassian';
+/** The version this server announces; always the package version, never a separate constant. */
+export const SERVER_VERSION = version;
+const INSTRUCTIONS = 'Tools mirror the simply-atlassian CLI one to one and return the raw Atlassian API payload as ' +
+    'JSON text, calling the same library the CLI is built on. Only read tools are registered unless ' +
+    'the server was started with --allow-writes. Every write tool accepts dryRun: true to preview ' +
+    'the request without sending it, and the irreversible ones (issue and comment deletes, and a ' +
+    'page purge) additionally require confirm: true. Failures come back as isError results whose ' +
+    'text is JSON with a stable "code": config, auth, error, or confirm-required. Prefer "fields" ' +
+    'on issue tools to keep payloads small.';
+const ANNOTATIONS = {
+    read: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    write: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    destructive: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+};
+/** Which tools a server with the given options registers. Exported so `--help` can list them. */
+export function selectTools(allowWrites) {
+    return allowWrites ? TOOLS : TOOLS.filter((tool) => tool.kind === 'read');
+}
+/**
+ * Builds the MCP server with its metadata and tools registered, but not yet connected to a
+ * transport. Kept separate from {@link startServer} so tests can attach an in-memory transport
+ * and a host process can embed the server over whatever transport it runs.
+ */
+export function createServer(options = {}) {
+    const context = createContext(options);
+    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { instructions: INSTRUCTIONS });
+    for (const spec of selectTools(context.allowWrites)) {
+        server.registerTool(spec.name, {
+            title: spec.title,
+            description: spec.description,
+            inputSchema: spec.inputSchema,
+            annotations: { title: spec.title, ...ANNOTATIONS[spec.kind] },
+        }, (input) => invokeTool(spec, context, input));
+    }
+    return server;
+}
+/**
+ * Creates the server and serves it over stdio, which is how MCP clients such as Claude Desktop,
+ * Claude Code, and Cursor launch a local server. Resolves once the transport is connected; the
+ * process then stays alive until the client closes the stream.
+ */
+export async function startServer(options = {}) {
+    const server = createServer(options);
+    await server.connect(new StdioServerTransport());
+    return server;
+}
+/**
+ * Runs one tool call end to end: the `confirm` gate, the read-only guard, the operation, and
+ * the mapping of a failure onto a tool result. Never throws for an operational failure — those
+ * are `isError` results the agent can read and act on — and only lets a genuine bug propagate.
+ */
+export async function invokeTool(spec, context, input) {
+    // Gated here, before anything is looked up, so a call without consent never reaches the
+    // instance even though the operation would refuse it too. `dryRun` is exempt: previewing
+    // needs no consent.
+    const needsConfirm = spec.kind === 'destructive' && (spec.requiresConfirm?.(input) ?? true);
+    if (needsConfirm && input.dryRun !== true && input.confirm !== true) {
+        return errorResult({
+            code: 'confirm-required',
+            name: 'ConfirmRequired',
+            message: `${spec.title} cannot be undone. Pass confirm: true to proceed, or dryRun: true to preview.`,
+            exitCode: 2,
+        });
+    }
+    try {
+        // The same guard the CLI applies before any write command runs, so a host that enables
+        // writes but points the server at a read-only credential file still gets the refusal.
+        if (spec.kind !== 'read')
+            assertWritesAllowed(context.env);
+        const result = await spec.run(context, input);
+        // Handed through untouched so the payload shape stays Atlassian's contract, not this server's.
+        return { content: [{ type: 'text', text: JSON.stringify(result ?? null) }] };
+    }
+    catch (error) {
+        return errorResult(mapError(error, context));
+    }
+}
+/**
+ * Turns a failure into the same object the CLI writes to stderr under `--json`, with the same
+ * scrubbing: the message and any response body are redacted of credentials and stripped of
+ * control characters before they reach an agent's context.
+ */
+export function mapError(error, context) {
+    const secrets = secretValues(context.env);
+    const clean = (text) => stripControl(redactSecrets(text, secrets));
+    const message = clean(error instanceof Error ? error.message : String(error));
+    if (error instanceof ConfigError)
+        return { code: 'config', name: error.name, message, exitCode: error.exitCode };
+    if (error instanceof AuthError) {
+        return { code: 'auth', name: error.name, message, exitCode: error.exitCode, status: error.status };
+    }
+    if (error instanceof HttpError) {
+        return {
+            code: 'error',
+            name: error.name,
+            message,
+            exitCode: error.exitCode,
+            status: error.status,
+            body: sanitiseDeep(error.body, secrets),
+        };
+    }
+    if (error instanceof CliError)
+        return { code: 'error', name: error.name, message, exitCode: error.exitCode };
+    return { code: 'error', name: 'Error', message, exitCode: 1 };
+}
+function errorResult(error) {
+    return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+}
+//# sourceMappingURL=server.js.map

package/lib/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/lib/tools.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { ToolContext } from './context.js';
+/**
+ * What a tool does to the instance, which decides whether it is registered at all (only `read`
+ * tools without `--allow-writes`), which MCP annotations it carries, and whether `confirm` is
+ * demanded before it runs.
+ */
+export type ToolKind = 'read' | 'write' | 'destructive';
+export interface ToolSpec {
+    /** MCP tool name: `<product>_<noun>_<verb>`, snake case, stable across releases. */
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    /** The CLI command this tool is the equivalent of, e.g. `['atlassian', 'jira', 'issue', 'search']`. */
+    readonly command: readonly string[];
+    readonly kind: ToolKind;
+    readonly inputSchema: z.ZodRawShape;
+    /**
+     * For a destructive tool, whether this particular call needs `confirm`. Defaults to always;
+     * `confluence_page_delete` only needs it to purge, because trashing is reversible and the
+     * CLI does not demand `--confirm` for it either.
+     */
+    readonly requiresConfirm?: (input: Readonly<Record<string, unknown>>) => boolean;
+    /** Runs the tool against the instance and returns what the CLI would print under `--json`. */
+    readonly run: (context: ToolContext, input: Readonly<Record<string, unknown>>) => Promise<unknown>;
+}
+/**
+ * Every tool this server can register, one per CLI command. The `test/tools.test.ts` suite
+ * cross-checks this list against the CLI package's `command-snapshot.json`, so a command added
+ * to the CLI without a tool here fails CI rather than going quietly unexposed.
+ *
+ * Each handler returns exactly what the matching command returns under `--json`, and the logic
+ * between input and request is the core package's — the same functions the command calls — so
+ * a dry run, a refusal, or an error reads the same from either surface.
+ */
+export declare const TOOLS: readonly ToolSpec[];