@sonisoft/now-sdk-ext-mcp 1.0.0

package/README.md

@@ -0,0 +1,393 @@
+# now-sdk-ext-mcp
+
+An MCP (Model Context Protocol) server that enables AI assistants to interact directly with ServiceNow instances — executing background scripts, querying data, running ATF tests, tailing logs, and more.
+
+Built on [`@modelcontextprotocol/sdk`](https://github.com/modelcontextprotocol/typescript-sdk) and [`@sonisoft/now-sdk-ext-core`](https://git.sonisoft.io).
+
+## Quick Start
+
+### Prerequisites
+
+- **Node.js** >= 18
+- **ServiceNow CLI credentials** configured via `snc configure`
+
+### Install and Build
+
+```bash
+git clone <repo-url>
+cd now-sdk-ext-mcp
+npm install
+npm run build
+```
+
+### Configure Credentials
+
+This server uses the same credential store as the ServiceNow CLI (`snc`). If you haven't already, configure your instance credentials:
+
+```bash
+now-sdk auth --add <instance_alias>
+```
+
+This stores credentials locally so the MCP server can authenticate without prompting.
+
+### Run the Server
+
+```bash
+node dist/index.js
+```
+
+The server communicates over **stdio** (standard input/output) using the MCP JSON-RPC protocol. It is not meant to be run interactively — it's designed to be launched by an MCP client (Claude Desktop, VS Code, Cursor, etc.).
+
+## Connecting to an MCP Client
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "servicenow": {
+      "command": "node",
+      "args": ["/absolute/path/to/now-sdk-ext-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+To set a default instance (so you don't have to specify it every time):
+
+```json
+{
+  "mcpServers": {
+    "servicenow": {
+      "command": "node",
+      "args": ["/absolute/path/to/now-sdk-ext-mcp/dist/index.js"],
+      "env": {
+        "SN_AUTH_ALIAS": "dev224436"
+      }
+    }
+  }
+}
+```
+
+### VS Code / Cursor
+
+Add to your `.vscode/mcp.json` or Cursor MCP settings:
+
+```json
+{
+  "servers": {
+    "servicenow": {
+      "command": "node",
+      "args": ["/absolute/path/to/now-sdk-ext-mcp/dist/index.js"],
+      "env": {
+        "SN_AUTH_ALIAS": "dev224436"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+Add to your `.claude/settings.json` or project-level `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "servicenow": {
+      "command": "node",
+      "args": ["/absolute/path/to/now-sdk-ext-mcp/dist/index.js"],
+      "env": {
+        "SN_AUTH_ALIAS": "dev224436"
+      }
+    }
+  }
+}
+```
+
+### Opencode
+
+Add to your `.config/opencode/opencode.json` or project-level `opencode.jsonc`
+
+```json
+{
+  "mcp": {
+    "servicenow": {
+      "type": "local",
+      "command": ["node", "/absolute/path/to/now-sdk-ext-mcp/dist/index.js"],
+      "enabled": true,
+      "environment": {
+        "SN_AUTH_ALIAS": "dev224436"
+      }
+    }
+  }
+}
+
+## How It Works
+
+Once connected, you can talk to your AI assistant naturally:
+
+> "Find all CMDB CI records in the computer class on my dev224436 instance"
+
+> "Run a script on dev224436 that counts all active incidents by priority"
+
+> "Query the sys_user table for users with the admin role on prod"
+
+The AI will:
+1. Write the appropriate ServiceNow server-side JavaScript
+2. Call the `execute_script` tool with the instance alias and script
+3. Return the results in a readable format
+
+The `instance` parameter can be passed explicitly per-request or defaulted via the `SN_AUTH_ALIAS` environment variable, so if you only work with one instance you can set-and-forget.
+
+## Available Tools
+
+See **[TOOLS.md](TOOLS.md)** for the full list of available tools with parameters and examples.
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `SN_AUTH_ALIAS` | _(none)_ | Default ServiceNow auth alias. Used when a tool call doesn't specify an `instance` parameter. |
+
+## Development
+
+### Project Structure
+
+```
+src/
+├── index.ts                 # Server entry point — registers tools, starts stdio transport
+├── tools/                   # MCP tool implementations (one file per tool)
+│   └── execute-script.ts    # execute_script tool
+└── common/
+    └── connection.ts        # ServiceNow connection manager (credential resolution + caching)
+
+test/
+├── __mocks__/               # Manual mocks for external dependencies
+├── helpers/                 # Shared test utilities and factories
+├── unit/                    # Unit tests (mocked external deps)
+│   ├── common/
+│   └── tools/
+└── integration/             # Integration tests (full MCP protocol, no real SN calls)
+```
+
+### Scripts
+
+| Command | Description |
+|---------|-------------|
+| `npm run build` | Clean and compile TypeScript to `dist/` |
+| `npm run dev` | Build and run the server |
+| `npm test` | Run unit tests |
+| `npm run test:unit` | Run unit tests with coverage and junit reporting |
+| `npm run test:integration` | Run MCP protocol integration tests |
+| `npm run test:all` | Run all tests |
+| `npm run lint` | Type-check with `tsc --noEmit` |
+
+### Adding a New Tool
+
+1. Create a new file in `src/tools/` (e.g., `src/tools/query-table.ts`).
+2. Export a registration function:
+
+   ```typescript
+   import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+   import { z } from "zod";
+   import { getServiceNowInstance } from "../common/connection.js";
+
+   export function registerQueryTableTool(server: McpServer): void {
+     server.registerTool(
+       "query_table",
+       {
+         title: "Query Table",
+         description: "Query records from a ServiceNow table.",
+         inputSchema: {
+           instance: z.string().optional().describe("ServiceNow instance auth alias"),
+           table: z.string().describe("Table name to query"),
+           // ... more params
+         },
+       },
+       async ({ instance, table }) => {
+         const snInstance = await getServiceNowInstance(instance);
+         // ... use core library to query
+         return {
+           content: [{ type: "text" as const, text: "results here" }],
+         };
+       }
+     );
+   }
+   ```
+
+3. Register it in `src/index.ts`:
+
+   ```typescript
+   import { registerQueryTableTool } from "./tools/query-table.js";
+
+   registerQueryTableTool(server);
+   ```
+
+4. Add tests in `test/unit/tools/` following the existing pattern.
+5. Document the tool in [`TOOLS.md`](TOOLS.md).
+
+### Testing Approach
+
+Tests use the MCP SDK's `InMemoryTransport` to create linked client+server pairs entirely in-process. This means tests go through the full MCP protocol stack (JSON-RPC serialization, schema validation, handler dispatch) without spawning processes or touching the network.
+
+- **Unit tests** (`test/unit/`): Mock external dependencies (`@sonisoft/now-sdk-ext-core`, `@servicenow/sdk-cli`) using `jest.unstable_mockModule()` for ESM compatibility. Test tool behavior through the MCP client.
+- **Integration tests** (`test/integration/`): Verify the MCP protocol lifecycle (handshake, tool listing, sequential calls) without mocking.
+
+### Sibling Projects
+
+This MCP server wraps the same core library used by the CLI:
+
+- **Core library**: [`@sonisoft/now-sdk-ext-core`](../now-sdk-ext-core) — all ServiceNow communication (auth, HTTP, WebSocket, script execution, ATF, syslog)
+- **CLI**: [`@sonisoft/now-sdk-ext-cli`](../now-sdk-ext-cli) — the `nex` CLI that wraps the core library with oclif
+
+When adding new MCP tools, reference the corresponding CLI command in `now-sdk-ext-cli/src/commands/` for the expected behavior and data flow.
+
+## Contributing
+
+### Testing
+
+There are three layers of testing for this project:
+
+#### 1. Automated Tests (Jest)
+
+Unit and integration tests run entirely in-process using the MCP SDK's `InMemoryTransport` — no server process, no network, no credentials needed.
+
+```bash
+npm test                 # Unit tests (default, fast)
+npm run test:unit        # Unit tests with coverage + junit
+npm run test:integration # MCP protocol integration tests
+npm run test:all         # Everything
+```
+
+Unit tests mock all external dependencies (`@sonisoft/now-sdk-ext-core`, `@servicenow/sdk-cli`) so they are fast and deterministic. Integration tests verify the MCP protocol lifecycle (handshake, tool listing, tool calls, error responses) without hitting real ServiceNow instances.
+
+Always run `npm test` before committing.
+
+#### 2. MCP Inspector (Interactive Testing)
+
+The official [MCP Inspector](https://github.com/modelcontextprotocol/inspector) is a web UI that acts as an MCP client, letting you interactively browse tools, invoke them with custom inputs, and see results — without connecting to Claude or any AI client.
+
+```bash
+# Build first
+npm run build
+
+# Launch the inspector (opens a browser UI at http://localhost:6274)
+npx @modelcontextprotocol/inspector node dist/index.js
+
+# Pass env vars to the server (e.g., default instance alias)
+npx @modelcontextprotocol/inspector -e SN_AUTH_ALIAS=dev224436 node dist/index.js
+```
+
+In the inspector UI you can:
+- Browse registered tools and their input schemas in the **Tools** tab
+- Fill in parameters and invoke tools
+- See the JSON-RPC request/response and tool output
+- View server stderr logs in the **Notifications** pane
+
+The inspector also has a headless CLI mode for scripting:
+
+```bash
+# List all tools
+npx @modelcontextprotocol/inspector --cli node dist/index.js --method tools/list
+
+# Call a specific tool
+npx @modelcontextprotocol/inspector --cli node dist/index.js \
+  --method tools/call --tool-name execute_script \
+  --tool-arg instance=dev224436 \
+  --tool-arg script='gs.print("hello")' \
+  --tool-arg scope=global
+```
+
+#### 3. Testing with Claude Code
+
+To test the server end-to-end with Claude Code as the MCP client:
+
+**Add the server:**
+
+```bash
+# From the now-sdk-ext-mcp project root (after building):
+claude mcp add --transport stdio --env SN_AUTH_ALIAS=dev224436 servicenow \
+  -- node /absolute/path/to/now-sdk-ext-mcp/dist/index.js
+```
+
+Or create a `.mcp.json` at your project root (this is shareable via version control):
+
+```json
+{
+  "mcpServers": {
+    "servicenow": {
+      "command": "node",
+      "args": ["/absolute/path/to/now-sdk-ext-mcp/dist/index.js"],
+      "env": {
+        "SN_AUTH_ALIAS": "dev224436"
+      }
+    }
+  }
+}
+```
+
+**Verify the connection:**
+
+Inside a Claude Code session, run `/mcp` to see all connected servers and their status. The `servicenow` server should show as connected.
+
+**Test it:**
+
+Ask Claude something like:
+
+> "Run a script on dev224436 that prints the current user's name using gs.print(gs.getUserName())"
+
+Claude should call the `execute_script` tool and return the result.
+
+**Manage servers:**
+
+```bash
+claude mcp list              # List all configured servers
+claude mcp get servicenow    # Show details for the servicenow server
+claude mcp remove servicenow # Remove it
+```
+
+#### Manual stdin Testing
+
+Since the server communicates via JSON-RPC over stdio, you can pipe messages directly for quick smoke tests:
+
+```bash
+# List tools (single-message shortcut — works for basic inspection)
+echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' \
+  | node dist/index.js 2>/dev/null \
+  | jq '.result.tools[].name'
+```
+
+For a full protocol exchange (initialize handshake + tool call):
+
+```bash
+printf '%s\n%s\n%s\n' \
+  '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}},"id":0}' \
+  '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
+  '{"jsonrpc":"2.0","method":"tools/list","id":1}' \
+  | node dist/index.js 2>/dev/null \
+  | jq
+```
+
+### Debugging
+
+Since stdout is reserved for JSON-RPC, **never use `console.log()` in server code** — it corrupts the protocol stream. Use these approaches instead:
+
+- **`console.error()`** — writes to stderr, which is safe and visible in the MCP Inspector's Notifications pane and in Claude Desktop's log files (`~/Library/Logs/Claude/mcp*.log`).
+- **MCP Inspector** — run the server under the inspector to see all JSON-RPC messages and stderr output in real time.
+- **File logging** — for persistent debug logs, the core library's `Logger` class writes to `logs/` with Winston. Set the log level via the tool's logic as needed.
+
+### Code Conventions
+
+- ES Modules (`"type": "module"` in package.json)
+- TypeScript strict mode
+- Target ES2022, module Node16
+- Match the patterns and style of the sibling `now-sdk-ext-core` and `now-sdk-ext-cli` projects
+- Every tool that talks to ServiceNow should accept an optional `instance` parameter
+- Test every tool through the MCP client (not by calling handler functions directly) so the full protocol stack is exercised
+
+## License
+
+MIT

package/dist/common/connection.d.ts

@@ -0,0 +1,42 @@
+import { ServiceNowInstance } from "@sonisoft/now-sdk-ext-core";
+/**
+ * Returns a ServiceNowInstance using stored credentials from the ServiceNow
+ * CLI credential store (snc configure).
+ *
+ * Resolution order: explicit authAlias parameter → SN_AUTH_ALIAS env var.
+ * Throws if neither is available.
+ *
+ * Instances are cached per alias with a 30-minute TTL so that repeated
+ * calls reuse the same session, but stale sessions are automatically
+ * refreshed. This allows the AI to work with multiple instances in a
+ * single conversation (e.g., dev224436 and prod).
+ */
+export declare function getServiceNowInstance(authAlias?: string): Promise<ServiceNowInstance>;
+/**
+ * Evicts a cached instance so the next call to getServiceNowInstance()
+ * creates a fresh connection.
+ */
+export declare function clearInstance(authAlias?: string): void;
+/**
+ * Returns true if an HTTP response indicates a stale or dead session.
+ */
+export declare function isRetryableResponse(response: {
+    status?: number;
+    statusText?: string;
+} | null | undefined): boolean;
+/**
+ * Executes an operation against a ServiceNow instance with automatic retry.
+ *
+ * On the first attempt, uses the (possibly cached) instance. If the operation
+ * throws a retryable error, the cached instance is evicted and the operation
+ * is retried once with a fresh connection.
+ *
+ * Usage:
+ * ```ts
+ * return withConnectionRetry(instance, async (snInstance) => {
+ *   // ... use snInstance ...
+ * });
+ * ```
+ */
+export declare function withConnectionRetry<T>(authAlias: string | undefined, operation: (instance: ServiceNowInstance) => Promise<T>): Promise<T>;
+//# sourceMappingURL=connection.d.ts.map

package/dist/common/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/common/connection.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAEnB,MAAM,4BAA4B,CAAC;AA4BpC;;;;;;;;;;;GAWG;AACH,wBAAsB,qBAAqB,CACzC,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,kBAAkB,CAAC,CAmC7B;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAKtD;AAgBD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GACpE,OAAO,CAIT;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,GACtD,OAAO,CAAC,CAAC,CAAC,CAeZ"}

package/dist/common/connection.js

@@ -0,0 +1,119 @@
+import { getCredentials } from "@servicenow/sdk-cli/dist/auth/index.js";
+import { ServiceNowInstance, } from "@sonisoft/now-sdk-ext-core";
+/** Cache TTL — 30 minutes. ServiceNow sessions typically expire after idle time. */
+const CACHE_TTL_MS = 30 * 60 * 1000;
+const instanceCache = new Map();
+/**
+ * Resolves the auth alias from the explicit parameter or the SN_AUTH_ALIAS env var.
+ * Throws if neither is available.
+ */
+function resolveAlias(authAlias) {
+    const resolved = authAlias || process.env.SN_AUTH_ALIAS;
+    if (!resolved) {
+        throw new Error("No instance specified. Either pass an instance alias " +
+            '(e.g., "on my dev224436 instance") or set the SN_AUTH_ALIAS environment variable.');
+    }
+    return resolved;
+}
+/**
+ * Returns a ServiceNowInstance using stored credentials from the ServiceNow
+ * CLI credential store (snc configure).
+ *
+ * Resolution order: explicit authAlias parameter → SN_AUTH_ALIAS env var.
+ * Throws if neither is available.
+ *
+ * Instances are cached per alias with a 30-minute TTL so that repeated
+ * calls reuse the same session, but stale sessions are automatically
+ * refreshed. This allows the AI to work with multiple instances in a
+ * single conversation (e.g., dev224436 and prod).
+ */
+export async function getServiceNowInstance(authAlias) {
+    const resolvedAlias = resolveAlias(authAlias);
+    const cached = instanceCache.get(resolvedAlias);
+    if (cached) {
+        const age = Date.now() - cached.createdAt;
+        if (age < CACHE_TTL_MS) {
+            return cached.instance;
+        }
+        // TTL expired — evict and create fresh
+        console.error(`[connection] Cache TTL expired for "${resolvedAlias}", refreshing session`);
+        instanceCache.delete(resolvedAlias);
+    }
+    const credential = await getCredentials(resolvedAlias);
+    if (!credential) {
+        throw new Error(`No credentials found for auth alias "${resolvedAlias}". ` +
+            `Run "snc configure --auth ${resolvedAlias}" to set up credentials.`);
+    }
+    const snSettings = {
+        alias: resolvedAlias,
+        credential,
+    };
+    const instance = new ServiceNowInstance(snSettings);
+    instanceCache.set(resolvedAlias, {
+        instance,
+        createdAt: Date.now(),
+    });
+    return instance;
+}
+/**
+ * Evicts a cached instance so the next call to getServiceNowInstance()
+ * creates a fresh connection.
+ */
+export function clearInstance(authAlias) {
+    const resolved = authAlias || process.env.SN_AUTH_ALIAS;
+    if (resolved) {
+        instanceCache.delete(resolved);
+    }
+}
+/** Patterns that indicate a connection/session problem worth retrying. */
+const RETRYABLE_PATTERNS = /ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|socket hang up|fetch failed|No response|Body not XML/i;
+/**
+ * Returns true if the error looks like a transient connection or stale-session
+ * problem that could be fixed by creating a fresh ServiceNowInstance.
+ */
+function isRetryableError(error) {
+    if (!error)
+        return false;
+    const msg = error instanceof Error ? error.message : String(error);
+    return RETRYABLE_PATTERNS.test(msg);
+}
+/**
+ * Returns true if an HTTP response indicates a stale or dead session.
+ */
+export function isRetryableResponse(response) {
+    if (!response || response.status == null)
+        return true; // no response at all
+    if (response.status === 401)
+        return true; // session expired
+    return false;
+}
+/**
+ * Executes an operation against a ServiceNow instance with automatic retry.
+ *
+ * On the first attempt, uses the (possibly cached) instance. If the operation
+ * throws a retryable error, the cached instance is evicted and the operation
+ * is retried once with a fresh connection.
+ *
+ * Usage:
+ * ```ts
+ * return withConnectionRetry(instance, async (snInstance) => {
+ *   // ... use snInstance ...
+ * });
+ * ```
+ */
+export async function withConnectionRetry(authAlias, operation) {
+    const snInstance = await getServiceNowInstance(authAlias);
+    try {
+        return await operation(snInstance);
+    }
+    catch (error) {
+        if (isRetryableError(error)) {
+            console.error(`[connection] Retryable error detected, refreshing session and retrying: ${error}`);
+            clearInstance(authAlias);
+            const freshInstance = await getServiceNowInstance(authAlias);
+            return await operation(freshInstance);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=connection.js.map

package/dist/common/connection.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerExecuteScriptTool } from "./tools/execute-script.js";
+import { registerRunAtfTestTool, registerRunAtfTestSuiteTool, } from "./tools/atf.js";
+import { registerQueryTableTool } from "./tools/query-table.js";
+import { registerFindAtfTestsTool } from "./tools/find-atf-tests.js";
+import { registerQuerySyslogTool } from "./tools/query-syslog.js";
+import { registerLookupAppTool } from "./tools/lookup-app.js";
+import { registerLookupTableTool } from "./tools/lookup-table.js";
+import { registerLookupColumnsTool } from "./tools/lookup-columns.js";
+import { registerCodeSearchTool, registerListCodeSearchGroupsTool, registerListCodeSearchTablesTool, registerAddCodeSearchTableTool, } from "./tools/codesearch.js";
+import { registerDiscoverTableSchemaTool, registerExplainFieldTool, registerValidateCatalogTool, } from "./tools/schema.js";
+import { registerGetCurrentScopeTool, registerSetCurrentScopeTool, registerListScopedAppsTool, } from "./tools/scope.js";
+import { registerGetCurrentUpdateSetTool, registerListUpdateSetsTool, registerCreateUpdateSetTool, registerSetCurrentUpdateSetTool, registerInspectUpdateSetTool, registerCloneUpdateSetTool, registerMoveUpdateSetRecordsTool, } from "./tools/updateset.js";
+import { registerAddTaskCommentTool, registerAssignTaskTool, registerResolveIncidentTool, registerCloseIncidentTool, registerApproveChangeTool, registerFindTaskTool, } from "./tools/task.js";
+import { registerBatchCreateRecordsTool, registerBatchUpdateRecordsTool, } from "./tools/batch.js";
+import { registerListAttachmentsTool, registerGetAttachmentInfoTool, registerUploadAttachmentTool, } from "./tools/attachment.js";
+import { registerGetAppDetailsTool, registerValidateAppInstallTool, registerSearchStoreAppsTool, registerListCompanyAppsTool, registerInstallStoreAppTool, registerUpdateStoreAppTool, registerInstallFromAppRepoTool, registerPublishToAppRepoTool, } from "./tools/app-manager.js";
+import { registerCreateWorkflowTool } from "./tools/workflow.js";
+import { registerPullScriptTool, registerPushScriptTool, } from "./tools/scriptsync.js";
+import { registerCountRecordsTool, registerAggregateQueryTool, registerAggregateGroupedTool, } from "./tools/aggregate.js";
+import { registerCheckInstanceHealthTool } from "./tools/health.js";
+import { registerGetCmdbRelationshipsTool, registerTraverseCmdbGraphTool, } from "./tools/cmdb.js";
+import { registerListInstanceTablesTool, registerListPluginsTool, } from "./tools/discovery.js";
+import { registerQueryUpdateRecordsTool, registerQueryDeleteRecordsTool, } from "./tools/query-batch.js";
+const server = new McpServer({
+    name: "now-sdk-ext-mcp",
+    version: "1.0.0-alpha.0",
+});
+// Register tools
+registerExecuteScriptTool(server);
+registerRunAtfTestTool(server);
+registerRunAtfTestSuiteTool(server);
+registerQueryTableTool(server);
+registerFindAtfTestsTool(server);
+registerQuerySyslogTool(server);
+registerLookupAppTool(server);
+registerLookupTableTool(server);
+registerLookupColumnsTool(server);
+registerCodeSearchTool(server);
+registerListCodeSearchGroupsTool(server);
+registerListCodeSearchTablesTool(server);
+registerAddCodeSearchTableTool(server);
+registerDiscoverTableSchemaTool(server);
+registerExplainFieldTool(server);
+registerValidateCatalogTool(server);
+registerGetCurrentScopeTool(server);
+registerSetCurrentScopeTool(server);
+registerListScopedAppsTool(server);
+registerGetCurrentUpdateSetTool(server);
+registerListUpdateSetsTool(server);
+registerCreateUpdateSetTool(server);
+registerSetCurrentUpdateSetTool(server);
+registerInspectUpdateSetTool(server);
+registerAddTaskCommentTool(server);
+registerAssignTaskTool(server);
+registerResolveIncidentTool(server);
+registerCloseIncidentTool(server);
+registerApproveChangeTool(server);
+registerFindTaskTool(server);
+registerBatchCreateRecordsTool(server);
+registerBatchUpdateRecordsTool(server);
+registerListAttachmentsTool(server);
+registerGetAttachmentInfoTool(server);
+registerGetAppDetailsTool(server);
+registerValidateAppInstallTool(server);
+registerSearchStoreAppsTool(server);
+registerListCompanyAppsTool(server);
+registerInstallStoreAppTool(server);
+registerUpdateStoreAppTool(server);
+registerInstallFromAppRepoTool(server);
+registerPublishToAppRepoTool(server);
+registerCreateWorkflowTool(server);
+registerPullScriptTool(server);
+registerPushScriptTool(server);
+registerCountRecordsTool(server);
+registerAggregateQueryTool(server);
+registerAggregateGroupedTool(server);
+registerCheckInstanceHealthTool(server);
+registerGetCmdbRelationshipsTool(server);
+registerTraverseCmdbGraphTool(server);
+registerListInstanceTablesTool(server);
+registerListPluginsTool(server);
+registerQueryUpdateRecordsTool(server);
+registerQueryDeleteRecordsTool(server);
+registerCloneUpdateSetTool(server);
+registerMoveUpdateSetRecordsTool(server);
+registerUploadAttachmentTool(server);
+// Prevent the process from crashing silently on unexpected errors.
+// Log to stderr (stdout is reserved for JSON-RPC).
+process.on("uncaughtException", (error) => {
+    console.error("[now-sdk-ext-mcp] Uncaught exception:", error);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("[now-sdk-ext-mcp] Unhandled rejection:", reason);
+});
+// Start the server on stdio transport
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("now-sdk-ext-mcp server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map