@myna-sh/mcp 0.12.2 → 0.14.0

package/dist/main.d.ts

@@ -89,6 +89,18 @@ interface ToolOptions {
      * remote client must never be able to read the server's filesystem.
      */
     allowPathUploads: boolean;
+    /**
+     * Myna products the target project runs.
+     *
+     * Tools for a product are registered only when the project has it enabled.
+     * Omitting this registers the Content tools and nothing else — the
+     * conservative default, and the one that matters: a customer's saved agent
+     * configuration must not change shape because Myna shipped a second product.
+     * There are already 45+ tools on this server, and every one added degrades
+     * selection for all of them, so a project that does not run Feedback should
+     * never be shown Feedback's.
+     */
+    products?: readonly string[];
 }
 
 declare const SERVER_NAME = "myna";

package/dist/main.js

@@ -294,6 +294,45 @@ var ManagementClient = class {
   mutate(method, path, body, query) {
     return this.http.request(method, path, { body, query, idempotencyKey: this.idem() });
   }
+  /**
+   * Escape hatch: call any management endpoint, wrapped or not.
+   *
+   * The typed methods above cover the API, but never all of it at once — a
+   * route ships before its wrapper, or a caller needs a header the wrapper does
+   * not take. Without a documented way around the client, that caller hand-rolls
+   * `fetch` and loses everything this class provides: credential handling,
+   * retry policy, and RFC 9457 errors thrown as `MynaApiError` rather than left
+   * as an opaque body to parse. The escape hatch keeps all of it.
+   *
+   * `path` is version-relative (`/projects/x`), and a leading `/v1` is accepted
+   * and stripped — this is the one method whose paths are written by hand, and
+   * every example a caller copies from the docs carries the prefix.
+   *
+   * Unlike the typed mutations, no idempotency key is generated: sending one
+   * makes a request retry-eligible, and only the caller knows whether replaying
+   * this particular one is safe. Pass `idempotencyKey` to opt in.
+   *
+   * Returns the response envelope untouched — `{ data, pagination }` and all —
+   * because an escape hatch that reshapes the response is not one.
+   */
+  async raw(method, path, options = {}) {
+    const relative = path.startsWith("/v1/") ? path.slice(3) : path.startsWith("/") ? path : `/${path}`;
+    const response = await this.http.requestRaw(method, relative, options);
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    if (response.status === 204 || response.status === 304) {
+      return { status: response.status, headers, body: void 0 };
+    }
+    const text = await response.text();
+    if (!text) return { status: response.status, headers, body: void 0 };
+    try {
+      return { status: response.status, headers, body: JSON.parse(text) };
+    } catch {
+      return { status: response.status, headers, body: text };
+    }
+  }
   // --- Organizations --------------------------------------------------------
   organizations = {
     list: (signal) => this.get("/organizations", void 0, signal),
@@ -497,6 +536,147 @@ var ManagementClient = class {
       body
     )
   };
+  // --- Feedback: boards -----------------------------------------------------
+  /**
+   * Boards collect reports. A board's `formFields` is its intake form, declared
+   * with the same field DSL as a collection schema — so a QA board that needs a
+   * build number says so there, and gets the same validation as anything else
+   * in Myna.
+   */
+  boards = {
+    list: (project, signal) => this.get(`/projects/${enc(project)}/boards`, void 0, signal),
+    get: (project, board, signal) => this.get(`/projects/${enc(project)}/boards/${enc(board)}`, void 0, signal),
+    create: (project, body) => this.mutate("POST", `/projects/${enc(project)}/boards`, body),
+    update: (project, board, body) => this.mutate("PATCH", `/projects/${enc(project)}/boards/${enc(board)}`, body),
+    delete: (project, board) => this.mutate("DELETE", `/projects/${enc(project)}/boards/${enc(board)}`)
+  };
+  // --- Feedback: reports ----------------------------------------------------
+  /**
+   * Bug reports, QA findings, feedback, and feature requests.
+   *
+   * `get` deliberately returns everything at once — body, board guidance,
+   * custom fields, developer-supplied context, the full timeline with resolved
+   * actors, the attachment manifest with short-lived URLs, and the links.
+   * Assembling a bug report from six calls is the problem this product exists
+   * to remove, so its own client does not make you do it.
+   *
+   * A report reference may be an id (`rep_…`), a number, or `#number`.
+   */
+  reports = {
+    list: (project, opts = {}) => {
+      const { board, status, type, priority, assignee, labels, q, since, ...rest } = opts;
+      return this.page(`/projects/${enc(project)}/reports`, rest, {
+        board,
+        status: Array.isArray(status) ? status.join(",") : status,
+        type,
+        priority,
+        assignee,
+        labels: labels?.join(","),
+        q,
+        since
+      });
+    },
+    get: (project, report, signal) => this.get(
+      `/projects/${enc(project)}/reports/${enc(String(report))}`,
+      void 0,
+      signal
+    ),
+    create: (project, body) => this.mutate("POST", `/projects/${enc(project)}/reports`, body),
+    update: (project, report, body) => this.mutate(
+      "PATCH",
+      `/projects/${enc(project)}/reports/${enc(String(report))}`,
+      body
+    ),
+    comment: (project, report, body) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/comments`,
+      body
+    ),
+    resolve: (project, report, body = {}) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/resolve`,
+      body
+    ),
+    reopen: (project, report, body = {}) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/reopen`,
+      body
+    ),
+    /** Ask whoever reported it to confirm a fix. The human half of the loop. */
+    requestRetest: (project, report, body = {}) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/retest`,
+      body
+    ),
+    merge: (project, report, body) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/merge`,
+      body
+    ),
+    /**
+     * What has come in since a time or a release.
+     *
+     * The call to make before deciding what to work on: counts, groupings, and
+     * the reports themselves already ordered by priority then recency.
+     */
+    digest: (project, opts = {}, signal) => this.get(
+      `/projects/${enc(project)}/reports/digest`,
+      { since: opts.since, release: opts.release, limit: opts.limit },
+      signal
+    ),
+    similar: (project, report, signal) => this.get(
+      `/projects/${enc(project)}/reports/${enc(String(report))}/similar`,
+      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: (project, report, body) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/move`,
+      body
+    ),
+    link: (project, report, body) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/links`,
+      body
+    ),
+    /** One attachment, with a fresh short-lived URL. */
+    attachment: (project, report, attachment, signal) => this.get(
+      `/projects/${enc(project)}/reports/${enc(String(report))}/attachments/${enc(attachment)}`,
+      void 0,
+      signal
+    ),
+    createUpload: (project, body) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/attachments/uploads`,
+      body
+    ),
+    attach: (project, report, uploadIds) => this.mutate(
+      "POST",
+      `/projects/${enc(project)}/reports/${enc(String(report))}/attachments`,
+      { uploadIds }
+    )
+  };
+  // --- Feedback: ingest keys ------------------------------------------------
+  /**
+   * Publishable keys that let a website submit reports.
+   *
+   * 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.
+   */
+  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),
+    revoke: (project, key) => this.mutate("DELETE", `/projects/${enc(project)}/ingest-keys/${enc(key)}`)
+  };
   // --- Declared external checks ---------------------------------------------
   checks = {
     list: (project, signal) => this.get(`/projects/${enc(project)}/checks`, void 0, signal),
@@ -853,7 +1033,16 @@ var TOOL_CAPABILITY = {
   myna_list_assets: "assets:read",
   myna_get_asset: "assets:read",
   myna_upload_asset: "assets:write",
-  myna_update_asset: "assets:write"
+  myna_update_asset: "assets:write",
+  myna_list_reports: "feedback:read",
+  myna_get_report: "feedback:read",
+  myna_get_report_attachment: "feedback:read",
+  myna_find_similar_reports: "feedback:read",
+  myna_report_digest: "feedback:read",
+  myna_reply_to_report: "feedback:write",
+  myna_update_report: "feedback:write",
+  myna_resolve_report: "feedback:write",
+  myna_request_retest: "feedback:write"
 };
 function registerTools(server, registry, options = { allowPathUploads: true }) {
   server.registerTool(
@@ -1925,6 +2114,265 @@ function registerTools(server, registry, options = { allowPathUploads: true }) {
       }
     }
   );
+  if (options.products?.includes("feedback")) registerFeedbackTools(server, registry);
+}
+var reportArg = {
+  ...projectArg,
+  report: z.string().describe("Report id (rep_...), number, or #number.")
+};
+function registerFeedbackTools(server, registry) {
+  server.registerTool(
+    "myna_list_reports",
+    {
+      title: "List reports",
+      description: "List bug reports, QA findings, and feature requests, most recently active first. Filter by board, status, type, priority, assignee, labels, free-text search over title and body, and last-activity time. Returns compact rows; call myna_get_report for the whole picture.",
+      inputSchema: {
+        ...projectArg,
+        board: z.string().optional().describe("Board key, e.g. qa."),
+        status: z.string().optional().describe("Comma-separated: triage, open, in_progress, needs_retest, resolved, closed, duplicate, wont_fix, spam."),
+        type: z.string().optional().describe("bug, qa, feedback, or feature_request."),
+        priority: z.string().optional().describe("low, normal, high, or urgent."),
+        labels: z.string().optional().describe("Comma-separated labels; matches any."),
+        q: z.string().optional().describe("Full-text search over title and body."),
+        since: z.string().optional().describe("ISO timestamp; only reports active at or after it."),
+        limit: z.number().optional()
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const page = await client.reports.list(project, {
+          board: args.board,
+          status: args.status,
+          type: args.type,
+          priority: args.priority,
+          labels: args.labels?.split(","),
+          q: args.q,
+          since: args.since,
+          limit: args.limit
+        });
+        return ok(`${page.data.length} report(s).`, { reports: page.data, nextCursor: page.nextCursor });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_report",
+    {
+      title: "Get report",
+      description: "Everything known about one report, in a single call: the description, the board's guidance for answering it, custom fields, the environment the application supplied, the full timeline with named actors, an attachment manifest, and linked commits or pull requests. Use this before trying to reproduce or fix anything.",
+      inputSchema: { ...reportArg },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const report = await client.reports.get(project, args.report);
+        const summary = [
+          `#${report.number} ${report.title}`,
+          `${report.status} / ${report.priority} on board ${report.boardKey}`,
+          `${report.attachments.length} attachment(s), ${report.timeline.length} timeline entr(ies)`
+        ].join(" \u2014 ");
+        return ok(summary, report);
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_get_report_attachment",
+    {
+      title: "Get report attachment",
+      description: "Fetch one attachment from a report. Images come back as image content the model can actually look at; parsed logs come back structured. Attachment ids are listed by myna_get_report.",
+      inputSchema: { ...reportArg, attachment: z.string().describe("Attachment id (rat_...).") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const attachment = await client.reports.attachment(project, args.report, args.attachment);
+        if (attachment.kind === "image" && attachment.url) {
+          const response = await fetch(attachment.url);
+          if (response.ok) {
+            const buffer = Buffer.from(await response.arrayBuffer());
+            return {
+              content: [
+                { type: "text", text: `${attachment.filename} (${attachment.byteSize} bytes)` },
+                { type: "image", data: buffer.toString("base64"), mimeType: attachment.contentType }
+              ]
+            };
+          }
+        }
+        if (attachment.structured) {
+          return ok(`${attachment.filename} (parsed).`, { attachment });
+        }
+        return ok(
+          `${attachment.filename} \u2014 ${attachment.kind}, ${attachment.byteSize} bytes. Download it with the url field; it is short-lived.`,
+          { attachment }
+        );
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_reply_to_report",
+    {
+      title: "Reply to a report",
+      description: "Post a message on a report. visibility 'public' reaches whoever filed it; 'internal' is a note for the team and is the default. Say what changed and why, not that you are an AI.",
+      inputSchema: {
+        ...reportArg,
+        message: z.string(),
+        visibility: z.enum(["internal", "public"]).optional().describe("Defaults to internal. Use public to answer the reporter.")
+      },
+      annotations: { openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const report = await client.reports.comment(project, args.report, {
+          body: args.message,
+          visibility: args.visibility ?? "internal"
+        });
+        return ok(`Posted ${args.visibility ?? "internal"} reply on #${report.number}.`, { report });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_update_report",
+    {
+      title: "Triage a report",
+      description: "Set status, priority, assignee, labels, title, or body on a report. One tool rather than five, because triage is usually several of these at once.",
+      inputSchema: {
+        ...reportArg,
+        status: z.string().optional(),
+        priority: z.string().optional(),
+        assigneeId: z.string().nullable().optional().describe("User id, or null to unassign."),
+        labels: z.array(z.string()).optional().describe("Replaces the label set."),
+        title: z.string().optional(),
+        body: z.string().optional()
+      },
+      annotations: { openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const report = await client.reports.update(project, args.report, {
+          status: args.status,
+          priority: args.priority,
+          assigneeId: args.assigneeId,
+          labels: args.labels,
+          title: args.title,
+          body: args.body
+        });
+        return ok(`#${report.number} is now ${report.status} (${report.priority}).`, { report });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_resolve_report",
+    {
+      title: "Resolve a report",
+      description: "Mark a report resolved, link the commit or pull request that fixed it, and reply to the reporter \u2014 in one call. Set requestRetest to ask them to confirm the fix instead of closing it, which is usually the better move when you could not reproduce the problem yourself.",
+      inputSchema: {
+        ...reportArg,
+        reply: z.string().optional().describe("Public reply explaining what changed."),
+        commit: z.string().optional(),
+        pullRequest: z.string().optional(),
+        requestRetest: z.boolean().optional()
+      },
+      annotations: { openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const report = await client.reports.resolve(project, args.report, {
+          reply: args.reply,
+          commit: args.commit,
+          pullRequest: args.pullRequest,
+          requestRetest: args.requestRetest
+        });
+        return ok(
+          args.requestRetest ? `#${report.number} is awaiting the reporter's confirmation.` : `#${report.number} resolved.`,
+          { report }
+        );
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_request_retest",
+    {
+      title: "Ask for a retest",
+      description: "Move a report to needs_retest and ask whoever filed it to confirm the fix. This is how the loop closes back to a human; prefer it over silently closing something you could not verify.",
+      inputSchema: { ...reportArg, note: z.string().optional().describe("What they should check.") },
+      annotations: { openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const report = await client.reports.requestRetest(project, args.report, { note: args.note });
+        return ok(`Asked for a retest on #${report.number}.`, { report });
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "myna_report_digest",
+    {
+      title: "Report digest",
+      description: "What has been reported since a time or a release: counts by status, board and type, plus the reports themselves already ordered by priority then recency. Call this before deciding what to work on \u2014 it answers in one request what would otherwise be several pages of myna_list_reports.",
+      inputSchema: {
+        ...projectArg,
+        since: z.string().optional().describe("ISO timestamp. Defaults to the last 24 hours."),
+        release: z.number().optional().describe("Since this release number shipped."),
+        limit: z.number().optional()
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const digest = await client.reports.digest(project, {
+          since: args.since,
+          release: args.release,
+          limit: args.limit
+        });
+        return ok(
+          `${digest.total} report(s) since ${digest.sinceLabel}; ${digest.stillOpen} still open.`,
+          digest
+        );
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  server.registerTool(
+    "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.",
+      inputSchema: { ...reportArg },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        const { client, project } = registry.clientFor(args.project);
+        const result = await client.reports.similar(project, args.report);
+        return ok(`${result.reports.length} candidate(s).`, result);
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
 }
 
 // src/resources.ts
@@ -1999,7 +2447,7 @@ function registerResources(server, registry) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.12.2" : "0.0.0-dev";
+var VERSION = true ? "0.14.0" : "0.0.0-dev";
 
 // src/server.ts
 var SERVER_NAME = "myna";