@wardby/cli 0.2.1 → 0.4.0

package/dist/providers/issue-tracker/jira-events.js

@@ -0,0 +1,98 @@
+/**
+ * Jira Cloud webhook → host-neutral IssueEvent. Pure: no I/O. The signature
+ * is WebSub-style (X-Hub-Signature: <method>=<hex HMAC of the raw body>);
+ * only sha256 is accepted. Actors that aren't licensed humans (JSM
+ * customers, apps) and the bot itself never produce an event.
+ */
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { adfMentionIds, adfToText } from "./adf.js";
+import { ISSUE_KEY, projectOf } from "./types.js";
+const MAX_TEXT = 20_000;
+export function verifyJiraSignature(rawBody, header, secret) {
+    if (!header || !/^sha256=[0-9a-f]{64}$/i.test(header))
+        return false;
+    const expected = createHmac("sha256", secret).update(rawBody, "utf8").digest();
+    const presented = Buffer.from(header.slice("sha256=".length), "hex");
+    return presented.length === expected.length && timingSafeEqual(presented, expected);
+}
+const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : null);
+const str = (v) => (typeof v === "string" ? v : "");
+function humanActor(user, bot) {
+    const u = obj(user);
+    if (!u || typeof u.accountId !== "string" || u.accountType !== "atlassian" || u.accountId === bot)
+        return null;
+    return { accountId: u.accountId, displayName: str(u.displayName) };
+}
+const words = (s) => str(s).split(/\s+/).filter(Boolean);
+function getChangelogField(item, field) {
+    return item[field];
+}
+export function normalizeJiraEvent(payload, botAccountId) {
+    const p = obj(payload);
+    if (!p)
+        return null;
+    const event = str(p.webhookEvent);
+    const issue = obj(p.issue);
+    const issueKey = str(issue?.key);
+    if (!ISSUE_KEY.test(issueKey))
+        return null;
+    const fields = obj(issue?.fields);
+    const subject = fields
+        ? { summary: str(fields.summary).slice(0, 256), description: adfToText(fields.description, MAX_TEXT) }
+        : undefined;
+    const base = {
+        provider: "jira",
+        projectKey: projectOf(issueKey),
+        issueKey,
+        addedLabels: [],
+        ...(subject ? { subject } : {}),
+    };
+    if (event === "jira:issue_created") {
+        const actor = humanActor(p.user, botAccountId);
+        return actor ? { ...base, kinds: ["created"], actor } : null;
+    }
+    if (event === "jira:issue_updated") {
+        const actor = humanActor(p.user, botAccountId);
+        if (!actor)
+            return null;
+        const items = Array.isArray(obj(p.changelog)?.items) ? obj(p.changelog).items.map(obj) : [];
+        const kinds = [];
+        const out = { ...base, kinds, actor };
+        for (const item of items) {
+            if (!item)
+                continue;
+            if (item.field === "status" && str(getChangelogField(item, "toString"))) {
+                kinds.push("transitioned");
+                out.toStatus = str(getChangelogField(item, "toString"));
+            }
+            else if (item.field === "labels") {
+                const before = new Set(words(getChangelogField(item, "fromString")));
+                const added = words(getChangelogField(item, "toString")).filter((l) => !before.has(l));
+                if (added.length) {
+                    kinds.push("labeled");
+                    out.addedLabels = added;
+                }
+            }
+            else if (item.field === "assignee" && typeof item.to === "string" && item.to) {
+                kinds.push("assigned");
+                out.assigneeAccountId = item.to;
+            }
+        }
+        return kinds.length ? out : null;
+    }
+    if (event === "comment_created" || event === "comment_updated") {
+        const comment = obj(p.comment);
+        // An edit is attributed to the editor, never the original author:
+        // otherwise anyone who can edit others' comments could reuse a trusted
+        // user's mention to pass the allowlist.
+        const actor = event === "comment_updated"
+            ? humanActor(comment?.updateAuthor, botAccountId)
+            : humanActor(comment?.author ?? p.user, botAccountId);
+        if (!actor || !comment || typeof comment.id !== "string")
+            return null;
+        if (!adfMentionIds(comment.body).includes(botAccountId))
+            return null;
+        return { ...base, kinds: ["mention"], actor, comment: { id: comment.id, body: adfToText(comment.body, MAX_TEXT) } };
+    }
+    return null;
+}

package/dist/providers/issue-tracker/jira.d.ts

@@ -0,0 +1,116 @@
+import type { JiraClient, RequestOptions } from "./jira-client.js";
+import { type CreateIssueInput, type CreateMetaField, type CreateMetaIssueType, type IssueSearchResult, type IssueSnapshot, type IssueTracker, type IssueTrackerIdentity, type IssueView, type TrackerCallOptions } from "./types.js";
+export declare const agentFooter: (agentId: string) => string;
+/** Whether rendered comment text ends with this agent's footer (as adfToText renders it: no markdown underscores). */
+export declare const hasAgentFooter: (text: string, agentId: string) => boolean;
+/** Whether rendered comment text ends with wardby's run-status footer (`_wardby run <id>_` as adfToText renders it). */
+export declare const isStatusComment: (text: string) => boolean;
+/**
+ * One call's budget (TrackerCallOptions): each request gets what is left of `timeoutMs`, and awaits that
+ * are not requests (the cached identity) are abandoned at the deadline. Without `timeoutMs`, a no-op.
+ */
+declare function callBudget(opts?: TrackerCallOptions): {
+    request(extra?: RequestOptions): RequestOptions;
+    within<T>(p: Promise<T>): Promise<T>;
+};
+type CallBudget = ReturnType<typeof callBudget>;
+export declare class JiraIssueTracker implements IssueTracker {
+    private readonly client;
+    private readonly siteUrl;
+    private readonly opts;
+    readonly provider: "jira";
+    private me;
+    constructor(client: JiraClient, siteUrl: string, opts?: {
+        epicLinkField?: string;
+    });
+    identity(): Promise<IssueTrackerIdentity>;
+    /** Refuses to act when the token belongs to a person; a failed identity() propagates and is not cached. */
+    private ready;
+    botAccountId(): Promise<string>;
+    /** Markdown to ADF, with this site's issue links (and the given projects' bare keys) as smart links. */
+    private toAdf;
+    issueUrl(key: string): string;
+    getIssue(key: string, opts: {
+        maxComments: number;
+        agentMarker: string;
+    } & TrackerCallOptions): Promise<IssueView>;
+    issueProject(key: string): Promise<string>;
+    snapshotIssue(key: string, opts?: {
+        timeoutMs?: number;
+        retryOn429?: boolean;
+    }): Promise<IssueSnapshot>;
+    search(jql: string, opts: {
+        maxResults: number;
+        timeoutMs?: number;
+        retryOn429?: boolean;
+    }): Promise<IssueSearchResult>;
+    matchesJql(key: string, jql: string, opts?: {
+        timeoutMs?: number;
+        retryOn429?: boolean;
+    }): Promise<boolean>;
+    comment(key: string, input: {
+        markdown: string;
+        visibilityRole?: string;
+        issueKeyProjects?: readonly string[];
+    }, opts?: TrackerCallOptions): Promise<{
+        id: string;
+        url: string;
+    }>;
+    editComment(key: string, commentId: string, input: {
+        markdown: string;
+        issueKeyProjects?: readonly string[];
+    }): Promise<void>;
+    readComment(key: string, commentId: string): Promise<{
+        authorId: string | null;
+        body: string;
+    } | null>;
+    transitions(key: string): Promise<Array<{
+        id: string;
+        name: string;
+        toStatus: string;
+        toCategory: string;
+    }>>;
+    transitionTo(key: string, toStatus: string): Promise<{
+        transitionId: string;
+        toStatus: string;
+    }>;
+    editableFields(key: string): Promise<string[]>;
+    editFields(key: string, fields: Record<string, unknown>): Promise<void>;
+    linkTypes(opts?: TrackerCallOptions): Promise<Array<{
+        name: string;
+        inward: string;
+        outward: string;
+    }>>;
+    linkIssues(input: {
+        type: string;
+        inwardKey: string;
+        outwardKey: string;
+    }, opts?: TrackerCallOptions): Promise<void>;
+    addRemoteLink(key: string, input: {
+        globalId: string;
+        url: string;
+        title: string;
+        status?: {
+            resolved: boolean;
+        };
+    }): Promise<void>;
+    getProperty(key: string, property: string): Promise<unknown>;
+    setProperty(key: string, property: string, value: unknown): Promise<void>;
+    /** Pages a createmeta endpoint (startAt/maxResults/total), capped. */
+    private pagedMeta;
+    createMeta(projectKey: string, budget?: CallBudget): Promise<{
+        issueTypes: CreateMetaIssueType[];
+    }>;
+    fieldMeta(projectKey: string, issueTypeId: string, budget?: CallBudget): Promise<CreateMetaField[]>;
+    createIssue(input: CreateIssueInput, opts?: TrackerCallOptions): Promise<{
+        key: string;
+        url: string;
+    }>;
+    readAttachmentText(id: string, maxBytes: number): Promise<{
+        filename: string;
+        mimeType: string;
+        text: string;
+        truncated: boolean;
+    }>;
+}
+export {};