@nimbus-dev/connectors 0.5.0 → 0.7.0

package/connectors/gitlab/src/tools.ts

@@ -5,6 +5,8 @@ import {
   type WriteToolConfig,
 } from "../../../shared/consent-kit.ts";
 import { optionalBaseUrl } from "../../../shared/env-json-api.ts";
+import { isSafeGitRef } from "../../../shared/github-rest.ts";
+import { guardedFetch } from "../../../shared/guarded-fetch.ts";
 import {
   createRegisterSimpleTool,
   createZodToolRegistrar,
@@ -20,6 +22,14 @@ import {
   toRestFetchResult,
 } from "../../../shared/rest-tool-kit.ts";
 
+/**
+ * A project reference that reaches a URL path: a numeric id, or `/`-separated segments of
+ * `[A-Za-z0-9._-]`, none of them `.` or `..` (a URL parser collapses those out of the path).
+ */
+function isSafeProjectPath(p: string): boolean {
+  return p.split("/").every((seg) => /^[A-Za-z0-9._-]+$/.test(seg) && seg !== "." && seg !== "..");
+}
+
 function apiBase(): string {
   return optionalBaseUrl("GITLAB_API_BASE_URL", "https://gitlab.com/api/v4");
 }
@@ -33,10 +43,13 @@ async function glFetch(token: string, path: string, init?: RequestInit): Promise
     init?.headers === undefined
       ? baseHeaders
       : { ...baseHeaders, ...(init.headers as Record<string, string>) };
-  const res = await fetch(url, {
-    ...init,
-    headers: mergedHeaders,
-  });
+  // guardedFetch: the PRIVATE-TOKEN header must never follow a redirect to another origin.
+  const res = await guardedFetch(
+    "GitLab",
+    url,
+    { ...init, headers: mergedHeaders },
+    { requireSecureBase: false },
+  );
   return toRestFetchResult(res);
 }
 
@@ -113,7 +126,12 @@ async function fetchJobTrace(parsed: {
   const token = requireProcessEnv("GITLAB_PAT");
   const enc = encodeURIComponent(parsed.projectPath);
   const url = `${apiBase()}/projects/${enc}/jobs/${String(parsed.jobId)}/trace`;
-  const res = await fetch(url, { headers: { "PRIVATE-TOKEN": token } });
+  const res = await guardedFetch(
+    "GitLab",
+    url,
+    { headers: { "PRIVATE-TOKEN": token } },
+    { requireSecureBase: false },
+  );
   const text = await res.text();
   if (!res.ok) {
     throw new Error(`GitLab ${String(res.status)}: ${text.slice(0, 300)}`);
@@ -135,6 +153,9 @@ export const GITLAB_TOOL_NAMES = [
   "gitlab_issue_labels_add",
   "gitlab_issue_assignees_add",
   "gitlab_issue_state_set",
+  "gitlab_branch_create",
+  "gitlab_mr_create",
+  "gitlab_mr_update",
   "gitlab_pipeline_list",
   "gitlab_pipeline_get",
   "gitlab_pipeline_jobs_get",
@@ -197,7 +218,7 @@ export function registerGitlabTools(
   const projectPathArg = z.object({
     projectPath: z
       .string()
-      .min(1)
+      .refine(isSafeProjectPath, "not a valid project path or numeric id")
       .describe("URL-encoded path or numeric project id, e.g. group/repo"),
   });
 
@@ -244,11 +265,14 @@ export function registerGitlabTools(
       `/projects/${encodeURIComponent(parsed.projectPath)}/merge_requests/${String(parsed.mergeRequestIid)}`,
   );
 
+  const FULL_SHA = /^[0-9a-f]{40}$/i;
+
   const gitlabMrMergeSchema = projectPathArg.extend({
     mergeRequestIid: z.number().int().min(1),
     mergeCommitMessage: z.string().max(10_000).optional(),
     squash: z.boolean().optional(),
     shouldRemoveSourceBranch: z.boolean().optional(),
+    sha: z.string().regex(FULL_SHA, "a full 40-hex commit sha").optional(),
   });
 
   registerGitlabWriteTool(
@@ -257,7 +281,7 @@ export function registerGitlabTools(
       mutates: "gitlab.mr.merge",
       recoverable: true,
     },
-    "Merge a merge request.",
+    "Merge a merge request. If `sha` (40 hex) is given it is sent as the API's `sha` parameter, and GitLab fails the merge when the source branch head is no longer that commit (https://docs.gitlab.com/api/merge_requests/#merge-a-merge-request).",
     gitlabMrMergeSchema,
     (parsed) =>
       `/projects/${encodeURIComponent(parsed.projectPath)}/merge_requests/${String(parsed.mergeRequestIid)}/merge`,
@@ -272,6 +296,9 @@ export function registerGitlabTools(
       if (parsed.shouldRemoveSourceBranch !== undefined) {
         body["should_remove_source_branch"] = parsed.shouldRemoveSourceBranch;
       }
+      if (parsed.sha !== undefined) {
+        body["sha"] = parsed.sha;
+      }
       return {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
@@ -388,18 +415,23 @@ export function registerGitlabTools(
       // header), so this one request bypasses glFetch. Never the private_token query parameter:
       // a token in a URL is logged.
       const res = await toRestFetchResult(
-        await fetch(graphqlUrl(), {
-          method: "POST",
-          headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-          body: JSON.stringify({
-            query: SET_ASSIGNEES_APPEND,
-            variables: {
-              projectPath: parsed.projectPath,
-              iid: String(parsed.issueIid),
-              assigneeUsernames: parsed.assigneeUsernames,
-            },
-          }),
-        }),
+        await guardedFetch(
+          "GitLab",
+          graphqlUrl(),
+          {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({
+              query: SET_ASSIGNEES_APPEND,
+              variables: {
+                projectPath: parsed.projectPath,
+                iid: String(parsed.issueIid),
+                assigneeUsernames: parsed.assigneeUsernames,
+              },
+            }),
+          },
+          { requireSecureBase: false },
+        ),
       );
       if (!res.ok) {
         throw new Error(`GitLab ${String(res.status)}: ${res.text.slice(0, 300)}`);
@@ -421,6 +453,141 @@ export function registerGitlabTools(
     (parsed) => jsonBody("PUT", { state_event: parsed.stateEvent }),
   );
 
+  /**
+   * A branch or ref name placed in a URL and sent to GitLab: the same rule as GitHub's
+   * (`isSafeGitRef`, ASCII only, so no format, control or surrogate character can pass).
+   */
+  const gitlabRefSchema = z
+    .string()
+    .min(1)
+    .max(255)
+    .refine(isSafeGitRef, "not a valid branch or ref name");
+
+  /**
+   * A branch name that goes in a JSON body: GitLab's own rules apply, but a format (invisible or
+   * bidi), control or lone-surrogate character is refused, so an approval prompt shows what is sent.
+   */
+  const branchNameSchema = z
+    .string()
+    .min(1)
+    .max(255)
+    .refine(
+      (v) => !/[\p{Cf}\p{Cc}\p{Cs}]/u.test(v),
+      "branch name has an invisible or control character",
+    );
+
+  registerWriteTool(
+    "gitlab_branch_create",
+    // A new branch is undone by deleting it, so nothing needs capturing first.
+    {
+      mutates: "gitlab.branch.create",
+      recoverable: true,
+      scopeTargetOf: (p) => ({ kind: "repo", value: p.projectPath }),
+    },
+    "Create a branch from a branch, tag or commit (fromRef). If expectedSha (40 hex) is given, fromRef is first resolved to a commit: when that commit is not expectedSha nothing is created, otherwise the branch is created from exactly that commit.",
+    projectPathArg.extend({
+      branch: gitlabRefSchema,
+      fromRef: gitlabRefSchema,
+      expectedSha: z.string().regex(FULL_SHA).optional(),
+    }),
+    async (parsed) => {
+      const token = requireProcessEnv("GITLAB_PAT");
+      const project = encodeURIComponent(parsed.projectPath);
+      let ref = parsed.fromRef;
+      if (parsed.expectedSha !== undefined) {
+        // https://docs.gitlab.com/api/commits/#get-a-single-commit — `sha` is a hash or a branch or
+        // tag name; the response's `id` is the full commit hash.
+        const commit = await glFetch(
+          token,
+          `/projects/${project}/repository/commits/${encodeURIComponent(parsed.fromRef)}`,
+        );
+        const id = (commit.json as { id?: unknown } | null)?.id;
+        if (!commit.ok || typeof id !== "string" || !FULL_SHA.test(id)) {
+          throw new Error(`GitLab ${String(commit.status)}: ${commit.text.slice(0, 300)}`);
+        }
+        if (id.toLowerCase() !== parsed.expectedSha.toLowerCase()) {
+          throw new Error(`fromRef resolves to ${id}, not the approved ${parsed.expectedSha}`);
+        }
+        ref = id.toLowerCase();
+      }
+      const res = await glFetch(
+        token,
+        listUrl(`/projects/${project}/repository/branches`, (q) => {
+          q.set("branch", parsed.branch);
+          q.set("ref", ref);
+        }),
+        { method: "POST" },
+      );
+      return mcpJsonResultIfOk("GitLab", res);
+    },
+  );
+
+  registerGitlabWriteTool(
+    "gitlab_mr_create",
+    { mutates: "gitlab.mr.create", recoverable: true },
+    "Open a merge request from sourceBranch into targetBranch. Title and description are sent exactly as given.",
+    projectPathArg.extend({
+      sourceBranch: branchNameSchema,
+      targetBranch: branchNameSchema,
+      title: z.string().min(1).max(255),
+      description: z.string().max(65_000).optional(),
+    }),
+    (parsed) => `/projects/${encodeURIComponent(parsed.projectPath)}/merge_requests`,
+    (parsed) =>
+      jsonBody("POST", {
+        source_branch: parsed.sourceBranch,
+        target_branch: parsed.targetBranch,
+        title: parsed.title,
+        ...(parsed.description === undefined ? {} : { description: parsed.description }),
+      }),
+  );
+
+  // A plain object, not a `.refine()`d one: the registrar passes `.shape` as the MCP inputSchema and a
+  // refined object has none. The at-least-one check is the handler's.
+  const mrPath = (p: { projectPath: string; mergeRequestIid: number }): string =>
+    `/projects/${encodeURIComponent(p.projectPath)}/merge_requests/${String(p.mergeRequestIid)}`;
+
+  registerGitlabWriteTool(
+    "gitlab_mr_update",
+    {
+      mutates: "gitlab.mr.update",
+      // An edit overwrites text; its inverse needs the old text, so capture it first.
+      recoverable: false,
+      capturePreState: async (parsed) => {
+        const token = requireProcessEnv("GITLAB_PAT");
+        const res = await glFetch(token, mrPath(parsed));
+        const mr = res.json as {
+          title?: unknown;
+          description?: unknown;
+          target_branch?: unknown;
+        } | null;
+        if (!res.ok || mr === null) return { resolved: false, status: res.status };
+        return { title: mr.title, description: mr.description, target_branch: mr.target_branch };
+      },
+    },
+    "Edit a merge request's title, description or target branch (at least one). It never closes, reopens or merges it.",
+    gitlabMrGetSchema.extend({
+      title: z.string().min(1).max(255).optional(),
+      description: z.string().max(65_000).optional(),
+      targetBranch: branchNameSchema.optional(),
+    }),
+    mrPath,
+    (parsed) => {
+      if (
+        parsed.title === undefined &&
+        parsed.description === undefined &&
+        parsed.targetBranch === undefined
+      ) {
+        throw new Error("gitlab_mr_update needs at least one of title, description, targetBranch");
+      }
+      return jsonBody("PUT", {
+        ...(parsed.title === undefined ? {} : { title: parsed.title }),
+        ...(parsed.description === undefined ? {} : { description: parsed.description }),
+        ...(parsed.targetBranch === undefined ? {} : { target_branch: parsed.targetBranch }),
+      });
+    },
+  );
+
   const gitlabPipelineListSchema = projectPathArg.extend({
     ref: z.string().max(500).optional(),
     status: z.string().max(64).optional(),

package/connectors/google-drive/src/tools.ts

@@ -470,9 +470,17 @@ export function registerGoogleDriveTools(
     fileId: z.string().min(1),
   });
 
-  registerDriveTool(
+  // A write, not a read: it was registered as a read before 0.6.0, so outside the gateway it had
+  // no consent gate (the gateway already classified it as `google_drive.file.trash`).
+  registerDriveWriteTool(
     "gdrive_file_trash",
-    "Move a Drive file or folder to trash (recoverable). Requires Gateway HITL file.delete.",
+    {
+      mutates: "google_drive.file.trash",
+      // Drive keeps a trashed item for 30 days and it can be restored from the trash.
+      recoverable: true,
+      scopeTargetOf: (p) => ({ kind: "file", value: p.fileId }),
+    },
+    "Move a Drive file or folder to trash (recoverable from the Drive trash for 30 days). Requires Gateway HITL google_drive.file.trash.",
     gdriveFileTrashArgs,
     (args, token) => drivePatchJson(token, args.fileId, { trashed: true }),
   );

package/connectors/jira/nimbus.extension.json

@@ -2,7 +2,7 @@
   "id": "com.nimbus.jira",
   "displayName": "Jira",
   "version": "0.1.0",
-  "description": "Jira REST connector (issues, search, projects). Tenant host (`*.atlassian.net`) comes from jira.base_url; PR 1 static manifest lists the API gateway only. Mutations require Gateway HITL.",
+  "description": "Jira REST connector (issues, search, projects, and JSM Operations alerts: get, list, request status, acknowledge, close). Tenant host (`*.atlassian.net`) comes from jira.base_url; PR 1 static manifest lists the API gateway only. Mutations require Gateway HITL.",
   "author": "Nimbus",
   "entrypoint": "dist/server.js",
   "runtime": "bun",

package/connectors/jira/src/tools.ts

@@ -49,6 +49,152 @@ function plainToAdf(text: string): Record<string, unknown> {
   };
 }
 
+type JiraConfig = { baseUrl: string; email: string; token: string };
+type HttpText = { ok: boolean; status: number; text: string };
+
+/** Atlassian's API gateway for JSM Operations. The host is fixed: it is never taken from an argument. */
+const OPS_API_ROOT = "https://api.atlassian.com/jsm/ops/api";
+
+/** A cloud id is a UUID. It enters a URL path, so anything else is refused, not encoded. */
+const CLOUD_ID_PATTERN = /^[0-9a-f-]{36}$/i;
+
+/** Discovered cloud ids, per site, for the life of the process. */
+const discoveredCloudIds = new Map<string, string>();
+
+/** Test seam: forget discovered cloud ids. */
+export function resetJiraCloudIdCacheForTests(): void {
+  discoveredCloudIds.clear();
+}
+
+function assertCloudId(value: unknown, source: string): string {
+  if (typeof value !== "string" || !CLOUD_ID_PATTERN.test(value)) {
+    throw new Error(
+      `${source} did not give a valid Jira cloud id; set JIRA_CLOUD_ID to the site's cloud id`,
+    );
+  }
+  return value;
+}
+
+/** A request is never allowed to follow a redirect: the credential goes only where it was aimed. */
+function refuseRedirect(what: string, res: HttpText): HttpText {
+  if (res.status >= 300 && res.status < 400) {
+    throw new Error(
+      `${what} answered ${String(res.status)} with a redirect; refused (for a write, it may or may not have been applied)`,
+    );
+  }
+  return res;
+}
+
+function isAtlassianCloudHost(baseUrl: string): boolean {
+  try {
+    // https only: over plain http an on-path attacker could answer tenant_info with another tenant's id.
+    const u = new URL(baseUrl);
+    return u.protocol === "https:" && u.hostname.toLowerCase().endsWith(".atlassian.net");
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The site's cloud id: `JIRA_CLOUD_ID` when set, else `GET {site}/_edge/tenant_info` once per
+ * process per site, only for an `*.atlassian.net` base (Atlassian's documented lookup, sent with the same Basic header as every other Jira call,
+ * so the credential goes only to the host it already goes to). Fails closed: no id, no ops call.
+ */
+async function resolveCloudId(cfg: JiraConfig): Promise<string> {
+  const configured = process.env["JIRA_CLOUD_ID"]?.trim();
+  if (configured !== undefined && configured !== "") {
+    return assertCloudId(configured, "JIRA_CLOUD_ID");
+  }
+  const cached = discoveredCloudIds.get(cfg.baseUrl);
+  if (cached !== undefined) return cached;
+  // tenant_info is an Atlassian Cloud endpoint. A Data Center or proxied site has none, so no
+  // request is made to guess: the owner names the cloud id.
+  if (!isAtlassianCloudHost(cfg.baseUrl)) {
+    throw new Error(
+      "JIRA_CLOUD_ID is required: JIRA_BASE_URL is not an *.atlassian.net site, so the cloud id cannot be discovered",
+    );
+  }
+  const res = refuseRedirect(
+    "Jira tenant_info",
+    await jiraFetch(cfg.baseUrl, cfg.email, cfg.token, "/_edge/tenant_info", {
+      redirect: "manual",
+    }),
+  );
+  if (!res.ok) {
+    throw new Error(
+      `Jira tenant_info ${String(res.status)}: could not discover the cloud id; set JIRA_CLOUD_ID`,
+    );
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(res.text);
+  } catch {
+    throw new Error("Jira tenant_info was not JSON; set JIRA_CLOUD_ID to the site's cloud id");
+  }
+  const id = assertCloudId((parsed as { cloudId?: unknown } | null)?.cloudId, "Jira tenant_info");
+  discoveredCloudIds.set(cfg.baseUrl, id);
+  return id;
+}
+
+/** One JSM Operations request: `https://api.atlassian.com/jsm/ops/api/{cloudId}/v1{path}`. */
+async function opsFetch(cfg: JiraConfig, path: string, init?: RequestInit): Promise<HttpText> {
+  const cloudId = await resolveCloudId(cfg);
+  const res = await fetchAtlassianBasicAuthJsonText(
+    `${OPS_API_ROOT}/${cloudId}/v1${path}`,
+    cfg.email,
+    cfg.token,
+    { ...init, redirect: "manual" },
+  );
+  return refuseRedirect("Jira Operations", res);
+}
+
+/** Ids that reach a path: the documented alert id, and request ids, are plain tokens. */
+const opsIdPattern = /^[A-Za-z0-9_-]{1,128}$/;
+
+const alertIdSchema = z.object({
+  alertId: z
+    .string()
+    .regex(opsIdPattern, "the alert id (not a tinyId or alias): letters, digits, '_' and '-'"),
+});
+
+/** What the audit record needs to understand an alert before it was acknowledged or closed. */
+async function alertPreState(parsed: { alertId: string }): Promise<Record<string, unknown>> {
+  const res = await opsFetch(requireJiraConfig(), `/alerts/${encodeURIComponent(parsed.alertId)}`);
+  if (!res.ok) {
+    throw new Error(`Jira Operations ${String(res.status)}: ${res.text.slice(0, 200)}`);
+  }
+  const alert = JSON.parse(res.text) as Record<string, unknown>;
+  return {
+    status: alert["status"],
+    acknowledged: alert["acknowledged"],
+    message: alert["message"],
+    priority: alert["priority"],
+  };
+}
+
+/** The 202 body of an async alert action, without claiming the action has happened. */
+function acceptedResult(res: HttpText): ReturnType<typeof jsonResult> {
+  if (!res.ok) {
+    throw new Error(`Jira Operations ${String(res.status)}: ${res.text.slice(0, 400)}`);
+  }
+  // A 2xx means Atlassian accepted the request; a body that is not JSON must not turn that into
+  // an error the owner would read as "nothing happened" and retry.
+  let body: { requestId?: unknown; took?: unknown } = {};
+  if (res.text !== "") {
+    try {
+      const parsed: unknown = JSON.parse(res.text);
+      if (parsed !== null && typeof parsed === "object") body = parsed;
+    } catch {
+      body = {};
+    }
+  }
+  return jsonResult({
+    status: "accepted",
+    requestId: typeof body.requestId === "string" ? body.requestId : null,
+    took: body.took,
+  });
+}
+
 /** Tool names exposed by this connector — for contract/introspection tests. */
 export const JIRA_TOOL_NAMES = [
   "jira_issue_list",
@@ -61,6 +207,11 @@ export const JIRA_TOOL_NAMES = [
   "jira_board_list",
   "jira_sprint_list",
   "jira_epic_list",
+  "jira_ops_alert_get",
+  "jira_ops_alert_list",
+  "jira_ops_alert_request_status",
+  "jira_ops_alert_acknowledge",
+  "jira_ops_alert_close",
 ] as const;
 
 export function registerJiraTools(
@@ -78,7 +229,7 @@ export function registerJiraTools(
   const registerWriteTool = createWriteToolRegistrar(server, {
     connector: "jira",
     scopeEnv: "NIMBUS_MCP_JIRA_WRITE_SCOPE",
-    scopeKinds: ["project", "issue"],
+    scopeKinds: ["project", "issue", "alert"],
   });
 
   const jiraIssueListSchema = z.object({
@@ -395,4 +546,106 @@ export function registerJiraTools(
       });
     },
   );
+
+  reg(
+    "jira_ops_alert_get",
+    "Get a Jira Service Management Operations alert by its id (GET /alerts/{id} on the JSM Operations API): status, acknowledged, message, priority, responders. Takes the alert id, not a tinyId or alias.",
+    alertIdSchema,
+    async (parsed) => {
+      const res = await opsFetch(
+        requireJiraConfig(),
+        `/alerts/${encodeURIComponent(parsed.alertId)}`,
+      );
+      return mcpJsonResultFromTextIfOk("Jira Operations", res, {
+        jsonParseErrorMessage: "Jira Operations: invalid JSON from alert get",
+      });
+    },
+  );
+
+  reg(
+    "jira_ops_alert_list",
+    "List Jira Service Management Operations alerts (GET /alerts). `query` is the Operations search query; `size` 1-100 (default 25); offset plus size must stay under 20000.",
+    z.object({
+      query: z.string().min(1).max(1000).optional(),
+      size: z.number().int().min(1).max(100).optional(),
+      offset: z.number().int().min(0).optional(),
+      sort: z.enum(["createdAt", "updatedAt"]).optional(),
+      order: z.enum(["asc", "desc"]).optional(),
+      from: z.string().min(1).max(64).optional(),
+      to: z.string().min(1).max(64).optional(),
+    }),
+    async (parsed) => {
+      const size = parsed.size ?? 25;
+      const offset = parsed.offset ?? 0;
+      if (offset + size >= 20_000) {
+        throw new Error("offset plus size must be lower than 20000");
+      }
+      const search = new URLSearchParams({ size: String(size), offset: String(offset) });
+      for (const key of ["query", "sort", "order", "from", "to"] as const) {
+        const value = parsed[key];
+        if (value !== undefined) search.set(key, value);
+      }
+      const res = await opsFetch(requireJiraConfig(), `/alerts?${search.toString()}`);
+      return mcpJsonResultFromTextIfOk("Jira Operations", res, {
+        jsonParseErrorMessage: "Jira Operations: invalid JSON from alert list",
+      });
+    },
+  );
+
+  reg(
+    "jira_ops_alert_request_status",
+    "Check an asynchronous alert action (GET /alerts/requests/{id}) with the requestId that jira_ops_alert_acknowledge or jira_ops_alert_close returned: whether it was processed and succeeded.",
+    z.object({ requestId: z.string().regex(opsIdPattern, "letters, digits, '_' and '-' only") }),
+    async (parsed) => {
+      const res = await opsFetch(
+        requireJiraConfig(),
+        `/alerts/requests/${encodeURIComponent(parsed.requestId)}`,
+      );
+      return mcpJsonResultFromTextIfOk("Jira Operations", res, {
+        jsonParseErrorMessage: "Jira Operations: invalid JSON from request status",
+      });
+    },
+  );
+
+  registerWriteTool(
+    "jira_ops_alert_acknowledge",
+    {
+      mutates: "jira.ops.alert.acknowledge",
+      // No unacknowledge tool is built, so the alert's state before is captured instead.
+      recoverable: false,
+      capturePreState: alertPreState,
+      scopeTargetOf: (p) => ({ kind: "alert", value: p.alertId }),
+    },
+    "Acknowledge a Jira Service Management Operations alert (POST /alerts/{id}/acknowledge; the API takes no body). The action is asynchronous: this returns {status: accepted, requestId}, not completion; check it with jira_ops_alert_request_status. Takes the alert id, not a tinyId or alias.",
+    alertIdSchema,
+    async (parsed) => {
+      const res = await opsFetch(
+        requireJiraConfig(),
+        `/alerts/${encodeURIComponent(parsed.alertId)}/acknowledge`,
+        { method: "POST" },
+      );
+      return acceptedResult(res);
+    },
+  );
+
+  registerWriteTool(
+    "jira_ops_alert_close",
+    {
+      mutates: "jira.ops.alert.close",
+      // The Operations API has no reopen, so the alert's state before is captured.
+      recoverable: false,
+      capturePreState: alertPreState,
+      scopeTargetOf: (p) => ({ kind: "alert", value: p.alertId }),
+    },
+    "Close a Jira Service Management Operations alert (POST /alerts/{id}/close; the API takes no body). It cannot be reopened through this API. The action is asynchronous: this returns {status: accepted, requestId}, not completion. To resolve an incident use jira_issue_transition; incidents are Jira issues.",
+    alertIdSchema,
+    async (parsed) => {
+      const res = await opsFetch(
+        requireJiraConfig(),
+        `/alerts/${encodeURIComponent(parsed.alertId)}/close`,
+        { method: "POST" },
+      );
+      return acceptedResult(res);
+    },
+  );
 }

package/connectors/launchdarkly/nimbus.extension.json

@@ -2,14 +2,14 @@
   "id": "com.nimbus.launchdarkly",
   "displayName": "LaunchDarkly",
   "version": "0.1.0",
-  "description": "LaunchDarkly feature-flag connector (read-only). Surfaces flag key, name, kind, tags, per-environment on/off state, maintainer, and timestamps into the local index as `launchdarkly:feature_flag` items — useful for incident correlation (\"was this flag enabled when the alert fired?\"). API-token auth. Regional / federal instances override `launchdarkly.base_url`; the SaaS host (app.launchdarkly.com) is the only one in the static sandbox manifest today (Task 14 runtime-merge follow-up). The `launchdarkly.flag.toggle` write tool is a deferred Phase 8 follow-up.",
+  "description": "LaunchDarkly feature-flag connector. Surfaces flag key, name, kind, tags, per-environment on/off state, maintainer, and timestamps into the local index as `launchdarkly:feature_flag` items — useful for incident correlation (\"was this flag enabled when the alert fired?\"). API-token auth. Regional / federal instances override `launchdarkly.base_url`; the SaaS host (app.launchdarkly.com) is the only one in the static sandbox manifest today (Task 14 runtime-merge follow-up). Write tools (each needs owner approval): `launchdarkly.flag.toggle` and `launchdarkly.flag.rollout.set`, one environment per call. The API token needs a role that can update flags.",
   "author": "Nimbus",
   "entrypoint": "dist/server.js",
   "runtime": "bun",
   "permissions": {
     "network": ["app.launchdarkly.com"]
   },
-  "hitlRequired": [],
+  "hitlRequired": ["write"],
   "syncInterval": 600,
   "minNimbusVersion": "0.2.0"
 }