@myna-sh/mcp 0.15.0 → 0.16.0

package/dist/main.js

@@ -564,7 +564,7 @@ var ManagementClient = class {
    */
   reports = {
     list: (project, opts = {}) => {
-      const { board, status, type, priority, assignee, labels, q, since, ...rest } = opts;
+      const { board, status, type, priority, assignee, labels, q, since, reporter, property, ...rest } = opts;
       return this.page(`/projects/${enc(project)}/reports`, rest, {
         board,
         status: Array.isArray(status) ? status.join(",") : status,
@@ -573,7 +573,9 @@ var ManagementClient = class {
         assignee,
         labels: labels?.join(","),
         q,
-        since
+        since,
+        reporter,
+        property
       });
     },
     get: (project, report, signal) => this.get(
@@ -629,13 +631,7 @@ var ManagementClient = class {
       void 0,
       signal
     ),
-    /** What publishing this report to a board would expose. Read before moving. */
-    exposure: (project, report, board, signal) => this.get(
-      `/projects/${enc(project)}/reports/${enc(String(report))}/exposure`,
-      { board },
-      signal
-    ),
-    /** Move between boards. A public destination needs `confirm: true`. */
+    /** Move a report to another board. Ordinary triage; every board is private. */
     move: (project, report, body) => this.mutate(
       "POST",
       `/projects/${enc(project)}/reports/${enc(String(report))}/move`,
@@ -669,14 +665,58 @@ var ManagementClient = class {
    *
    * Unlike every other credential here, one of these is *meant* to be readable
    * by every visitor to a customer's page. What makes that safe lives on the
-   * server: the key may only file on one board, only from an origin the project
-   * registered, and only within its own rate and quota budget.
+   * server: the key can only file a report and read back what the presenting
+   * reporter wrote, only from an origin the project registered, and only within
+   * its own rate and quota budget.
+   *
+   * Both `rotate` calls return the new secret and leave the old one working for
+   * 24 hours, so a frontend can be rebuilt and redeployed in between.
    */
   ingestKeys = {
     list: (project, signal) => this.get(`/projects/${enc(project)}/ingest-keys`, void 0, signal),
     create: (project, body) => this.mutate("POST", `/projects/${enc(project)}/ingest-keys`, body),
+    rotate: (project, key) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/ingest-keys/${enc(key)}/rotate`
+    ),
+    rotateIdentitySecret: (project, key) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/ingest-keys/${enc(key)}/rotate-identity-secret`
+    ),
     revoke: (project, key) => this.mutate("DELETE", `/projects/${enc(project)}/ingest-keys/${enc(key)}`)
   };
+  // --- Feedback: reporters --------------------------------------------------
+  /**
+   * The people who filed the reports.
+   *
+   * `verified` is the only field Myna stands behind: a signature the project's
+   * own backend produced. `properties` is what that backend said about its own
+   * user — true of their system, not checked here.
+   */
+  reporters = {
+    list: (project, opts = {}) => {
+      const { q, blocked, ...rest } = opts;
+      return this.page(`/projects/${enc(project)}/reporters`, rest, {
+        q,
+        blocked: blocked === void 0 ? void 0 : String(blocked)
+      });
+    },
+    /** By id (`rpr_…`), by the customer's own user id, or by email. */
+    get: (project, reporter, signal) => this.get(
+      `/projects/${enc(project)}/reporters/${enc(reporter)}`,
+      void 0,
+      signal
+    ),
+    /**
+     * Block or unblock. Blocking stops notifications and closes read-back; it
+     * never deletes what they already filed.
+     */
+    setBlocked: (project, reporter, body) => this.mutate(
+      "PATCH",
+      `/projects/${enc(project)}/reporters/${enc(reporter)}`,
+      body
+    )
+  };
   // --- Declared external checks ---------------------------------------------
   checks = {
     list: (project, signal) => this.get(`/projects/${enc(project)}/checks`, void 0, signal),
@@ -1039,10 +1079,15 @@ var TOOL_CAPABILITY = {
   myna_get_report_attachment: "feedback:read",
   myna_find_similar_reports: "feedback:read",
   myna_report_digest: "feedback:read",
+  myna_list_reporters: "feedback:read",
+  myna_get_reporter: "feedback:read",
   myna_reply_to_report: "feedback:write",
   myna_update_report: "feedback:write",
   myna_resolve_report: "feedback:write",
-  myna_request_retest: "feedback:write"
+  myna_request_retest: "feedback:write",
+  myna_merge_report: "feedback:write",
+  myna_move_report: "feedback:write",
+  myna_block_reporter: "feedback:manage"
 };
 function registerTools(server, registry, options = { allowPathUploads: true }) {
   server.registerTool(
@@ -2359,7 +2404,7 @@ function registerFeedbackTools(server, registry) {
     "myna_find_similar_reports",
     {
       title: "Find similar reports",
-      description: "Reports that might describe the same problem, by wording and by the route or URL the application reported. A ranking aid, not a verdict \u2014 each candidate says why it surfaced. Use it before fixing something twice, and to merge duplicates with myna_update_report.",
+      description: "Reports that might describe the same problem, by wording and by the route or URL the application reported. A ranking aid, not a verdict \u2014 each candidate says why it surfaced. Use it before fixing something twice, and to merge duplicates with myna_merge_report.",
       inputSchema: { ...reportArg },
       annotations: { readOnlyHint: true, openWorldHint: true }
     },
@@ -2373,6 +2418,132 @@ function registerFeedbackTools(server, registry) {
       }
     }
   );
+  server.registerTool(
+    "myna_merge_report",
+    {
+      title: "Merge a duplicate report",
+      description: "Mark a report as a duplicate of another. Nothing is deleted: the duplicate keeps its own timeline and points at the canonical report, because the second person to hit a bug usually said something the first did not. Confirm with myna_find_similar_reports first \u2014 a wrong merge buries a distinct problem.",
+      inputSchema: {
+        ...reportArg,
+        into: z.string().describe("The canonical report: an id, a number, or #number."),
+        note: z.string().optional().describe("Explains the merge on both timelines.")
+      },
+      annotations: { openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const report = await client.reports.merge(project, args.report, {
+          into: args.into,
+          note: args.note
+        });
+        return ok(`#${report.number} marked as a duplicate of ${args.into}.`, { report });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_move_report",
+    {
+      title: "Move a report to another board",
+      description: "Move a report to a different board on the same project \u2014 a bug filed on the ideas board, a QA finding that belongs with the bugs. Every board is private to the project, so this changes which queue the report sits in and nothing about who can read it.",
+      inputSchema: { ...reportArg, board: z.string().describe("Destination board key.") },
+      annotations: { openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const report = await client.reports.move(project, args.report, { board: args.board });
+        return ok(`#${report.number} moved to ${report.boardKey}.`, { report });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_list_reporters",
+    {
+      title: "List reporters",
+      description: "The people who have filed reports on this project: how many each has filed, when they were last active, whether their identity was signed by the application's own backend, and the properties that backend attached. Use it to see whether a wave of reports is one person or twenty.",
+      inputSchema: {
+        ...projectArg,
+        query: z.string().optional().describe("Match an email, display name, or external id."),
+        blocked: z.boolean().optional().describe("Only blocked reporters."),
+        limit: z.number().optional(),
+        cursor: z.string().optional()
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const page = await client.reporters.list(project, {
+          q: args.query,
+          blocked: args.blocked,
+          limit: args.limit,
+          cursor: args.cursor
+        });
+        return ok(`${page.data.length} reporter(s).`, {
+          reporters: page.data,
+          nextCursor: page.nextCursor
+        });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_reporter",
+    {
+      title: "Get a reporter",
+      description: "One reporter and everything they have filed, in one call. Reference them by Myna id (rpr_...), by the application's own user id, or by email address. Read this before answering somebody who has reported the same area three times.",
+      inputSchema: {
+        ...projectArg,
+        reporter: z.string().describe("Reporter id (rpr_...), your own user id, or an email address.")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const reporter = await client.reporters.get(project, args.reporter);
+        return ok(
+          `${reporter.displayName ?? reporter.email ?? reporter.id}: ${reporter.reportCount} report(s), ${reporter.verified ? "verified" : "unverified"}.`,
+          reporter
+        );
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_block_reporter",
+    {
+      title: "Block or unblock a reporter",
+      description: "Stop a reporter filing, reading their reports back, or being emailed \u2014 or let them back in. Nothing they already filed is deleted or hidden. This is moderation, not triage: use it for abuse, not for somebody who reports too much.",
+      inputSchema: {
+        ...projectArg,
+        reporter: z.string().describe("Reporter id (rpr_...), your own user id, or an email address."),
+        blocked: z.boolean().describe("True to block, false to unblock.")
+      },
+      annotations: { destructiveHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const reporter = await client.reporters.setBlocked(project, args.reporter, {
+          blocked: args.blocked
+        });
+        return ok(
+          `${reporter.displayName ?? reporter.email ?? reporter.id} is now ${reporter.blocked ? "blocked" : "active"}.`,
+          reporter
+        );
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
 }
 
 // src/resources.ts
@@ -2447,7 +2618,7 @@ function registerResources(server, registry) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.15.0" : "0.0.0-dev";
+var VERSION = true ? "0.16.0" : "0.0.0-dev";
 
 // src/server.ts
 var SERVER_NAME = "myna";