@wascartech/devbot 0.0.0-stage → 2.1.1

package/dist/platform/gitlab/index.js

@@ -0,0 +1,630 @@
+// GitLab driver: implements the Platform port by delegating to the existing
+// GitLab clients (gitlab.ts, gitlab-read.ts, admin-api.ts, oauth.ts,
+// gitlab-client.ts, webhook-signature.ts, attachments.ts). Behavior-preserving
+// extraction — the GitLab path is exactly what DevBot did before the abstraction.
+import { config } from "../../config.js";
+import { log } from "../../logger.js";
+import { randomBytes } from "node:crypto";
+import * as gitlab from "./api.js";
+import * as read from "./read.js";
+import * as admin from "./admin.js";
+import * as oauth from "./oauth.js";
+import { gitExtraHeaderGitlab } from "../git-auth.js";
+import { verifyWebhookSignature } from "./signature.js";
+import { findAttachmentRefs, downloadAttachment, uploadAttachment } from "./attachments.js";
+import { NoteHookPayloadSchema, WorkItemHookPayloadSchema, PipelineHookPayloadSchema } from "./schemas.js";
+// ---- Mappers ---------------------------------------------------------------
+function accessLevelToPermission(level) {
+    if (level >= 50)
+        return "owner";
+    if (level >= 40)
+        return "admin";
+    if (level >= 30)
+        return "write";
+    if (level >= 20)
+        return "read";
+    if (level >= 10)
+        return "read";
+    return "none";
+}
+function mapState(state) {
+    if (state === "opened")
+        return "open";
+    if (state === "merged")
+        return "merged";
+    if (state === "closed")
+        return "closed";
+    return state;
+}
+function toGitlabWorkItemState(state) {
+    if (state === "open")
+        return "opened";
+    return state;
+}
+function toGitlabMrState(state) {
+    if (state === "open")
+        return "opened";
+    return state;
+}
+function toGitlabMilestoneState(state) {
+    if (state === "open")
+        return "active";
+    return state;
+}
+// Neutral search scope -> GitLab `scope` query value.
+const GITLAB_SEARCH_SCOPE = {
+    code: "blobs",
+    issues: "issues",
+    merge_requests: "merge_requests",
+    commits: "commits",
+    wiki: "wiki_blobs",
+    notes: "notes",
+    users: "users",
+    milestones: "milestones",
+};
+function mapRepo(p) {
+    const path = p.path_with_namespace ?? p.full_name ?? "";
+    return {
+        id: p.id,
+        path,
+        webUrl: p.web_url ?? "",
+        cloneUrl: p.http_url_to_repo ?? p.git_http_url ?? `${config.PLATFORM_URL.replace(/\/$/, "")}/${path}.git`,
+        defaultBranch: p.default_branch ?? null,
+    };
+}
+// ---- Ingress ---------------------------------------------------------------
+const gitlabIngress = {
+    platform: "gitlab",
+    eventName(headers) {
+        const v = headers["x-gitlab-event"];
+        return Array.isArray(v) ? v[0] : v;
+    },
+    projectIdFromBody(body) {
+        const raw = body?.project?.id;
+        return typeof raw === "number" ? raw : undefined;
+    },
+    deliveryId(headers) {
+        const v = headers["webhook-id"];
+        return Array.isArray(v) ? v[0] : v;
+    },
+    verifySignature(secret, headers, rawBody, nowMs) {
+        return verifyWebhookSignature(secret, headers, rawBody, nowMs);
+    },
+    generateWebhookSecret() {
+        return "whsec_" + Buffer.from(randomBytes(32)).toString("base64");
+    },
+    parseWebhook(headers, body) {
+        const event = this.eventName(headers);
+        if (event === "Note Hook") {
+            // Cheap pre-filter on the wire value: merge-request, commit, wiki and
+            // snippet notes all arrive as "Note Hook" but are not work-item mentions,
+            // so they must not reach the schema (their shape is legitimately
+            // different) nor the schema-mismatch warning below.
+            const noteableType = body
+                ?.object_attributes?.noteable_type;
+            if (noteableType !== undefined && noteableType !== "Issue")
+                return null;
+            const parsed = NoteHookPayloadSchema.safeParse(body);
+            if (!parsed.success) {
+                // A signed payload we cannot read is schema drift, not an unhandled
+                // event: surface the failing field paths instead of dropping the
+                // mention silently behind a 204.
+                log.warn("gitlab webhook: Note Hook payload rejected", { issues: parsed.error.issues });
+                return null;
+            }
+            const p = parsed.data;
+            if (p.object_attributes.action !== "create")
+                return null;
+            return {
+                kind: "comment",
+                rawEvent: "Note Hook",
+                repo: mapRepo(p.project),
+                workItem: {
+                    id: p.issue.id,
+                    number: p.issue.iid,
+                    title: p.issue.title,
+                    description: p.issue.description ?? "",
+                    state: "open",
+                    webUrl: p.issue.url,
+                },
+                actor: { id: p.user.id, username: p.user.username, name: p.user.name },
+                body: p.object_attributes.note,
+                commentId: p.object_attributes.id,
+            };
+        }
+        if (event === "Issue Hook") {
+            const parsed = WorkItemHookPayloadSchema.safeParse(body);
+            if (!parsed.success) {
+                log.warn("gitlab webhook: Issue Hook payload rejected", { issues: parsed.error.issues });
+                return null;
+            }
+            const p = parsed.data;
+            const action = p.object_attributes.action;
+            if (action !== "open" && action !== "close")
+                return null;
+            return {
+                kind: action === "close" ? "workitem-close" : "workitem-open",
+                rawEvent: "Issue Hook",
+                repo: mapRepo(p.project),
+                workItem: {
+                    id: p.object_attributes.id,
+                    number: p.object_attributes.iid,
+                    title: p.object_attributes.title,
+                    description: p.object_attributes.description ?? "",
+                    state: action === "close" ? "closed" : "open",
+                    webUrl: p.object_attributes.url,
+                },
+                actor: { id: p.user.id, username: p.user.username, name: p.user.name },
+                body: p.object_attributes.description ?? "",
+            };
+        }
+        if (event === "Pipeline Hook") {
+            const parsed = PipelineHookPayloadSchema.safeParse(body);
+            if (!parsed.success) {
+                log.warn("gitlab webhook schema mismatch", { event, issues: parsed.error.issues });
+                return null;
+            }
+            const p = parsed.data;
+            if (p.object_attributes.status !== "failed")
+                return null;
+            const mr = p.merge_request;
+            return {
+                kind: "pipeline-failed",
+                rawEvent: "Pipeline Hook",
+                repo: mapRepo(p.project),
+                sourceBranch: mr?.source_branch ?? p.object_attributes.ref,
+                pipelineId: p.object_attributes.id,
+                ...(p.object_attributes.sha ? { commitSha: p.object_attributes.sha } : {}),
+                ...(mr ? { changeRequestNumber: mr.iid } : {}),
+            };
+        }
+        return null;
+    },
+};
+// `randomBytes` is imported at the top.
+// ---- Work items ------------------------------------------------------------
+const gitlabWorkItems = {
+    async postComment(repoId, number, body) {
+        const n = await gitlab.postNote(repoId, number, body);
+        return { id: n.id, body: n.body };
+    },
+    async replyInThread(repoId, number, commentId, body) {
+        const n = await gitlab.postDiscussionReply(repoId, number, String(commentId), body).catch(async () => {
+            return gitlab.postNote(repoId, number, body);
+        });
+        return { id: n.id, body: n.body };
+    },
+    async postErrorReply(repoId, number, triggeringCommentId, body) {
+        await gitlab.postErrorReply(repoId, number, triggeringCommentId, body);
+    },
+    async listComments(repoId, number) {
+        const notes = await gitlab.listIssueNotes(repoId, number);
+        return notes.map((n) => ({
+            id: n.id,
+            body: n.body,
+            ...(n.system !== undefined ? { system: n.system } : {}),
+            ...(n.author ? { author: n.author } : {}),
+            ...(n.created_at ? { createdAt: n.created_at } : {}),
+        }));
+    },
+    async getWorkItem(repoId, number) {
+        const i = await gitlab.getIssueFull(repoId, number);
+        return {
+            id: i.id,
+            number: i.iid,
+            title: i.title,
+            description: i.description ?? "",
+            state: mapState(i.state),
+            webUrl: i.web_url,
+            ...(i.author ? { author: { id: i.author.id } } : {}),
+            ...(i.assignees ? { assignees: i.assignees.map((a) => ({ id: a.id })) } : {}),
+        };
+    },
+    async getWorkItemStateOrNull(repoId, number) {
+        const s = await gitlab.fetchIssueStateOrNull(repoId, number);
+        if (s === null)
+            return null;
+        return s === "opened" ? "open" : "closed";
+    },
+    async getMemberPermission(repoId, user) {
+        // A non-member (404) is "none" rather than a lookup failure, so a
+        // minRole=none policy can admit any authenticated project member. 5xx still
+        // throws and the caller fails closed.
+        const m = await gitlab.fetchProjectMemberOrNull(repoId, user.id);
+        return m ? accessLevelToPermission(m.access_level) : "none";
+    },
+    async resolveUser(username) {
+        const u = await gitlab.findUserByUsername(username);
+        return u ? { id: u.id, username: u.username, name: u.name } : null;
+    },
+    async searchUsers(query, opts = {}) {
+        return read.searchUsers(query, opts);
+    },
+    async listWorkItems(repoId, opts = {}) {
+        const items = await gitlab.listIssues(repoId, {
+            ...(opts.state ? { state: toGitlabWorkItemState(opts.state) } : {}),
+            ...(opts.search ? { search: opts.search } : {}),
+            ...(opts.labels ? { labels: opts.labels } : {}),
+            ...(opts.page ? { page: opts.page } : {}),
+            ...(opts.perPage ? { perPage: opts.perPage } : {}),
+        });
+        return items.map(mapWorkItemSummary);
+    },
+    async getWorkItemSummary(repoId, number) {
+        return mapWorkItemSummary(await gitlab.getIssueFull(repoId, number));
+    },
+    async listCommentsFull(repoId, number, opts = {}) {
+        const notes = await read.listIssueNotesFull(repoId, number, opts);
+        return notes.map((n) => ({
+            id: n.id,
+            body: n.body,
+            ...(n.system !== undefined ? { system: n.system } : {}),
+            ...(n.author ? { author: n.author } : {}),
+            ...(n.created_at ? { createdAt: n.created_at } : {}),
+        }));
+    },
+    async listLabels(repoId, opts = {}) {
+        const labels = await read.listLabels(repoId, opts);
+        return labels.map((l) => ({
+            id: l.id,
+            name: l.name,
+            ...(l.color ? { color: l.color } : {}),
+            ...(l.description !== undefined ? { description: l.description } : {}),
+        }));
+    },
+    async listMilestones(repoId, opts = {}) {
+        const ms = await read.listMilestones(repoId, {
+            ...opts,
+            ...(opts.state ? { state: toGitlabMilestoneState(opts.state) } : {}),
+        });
+        return ms.map((m) => ({
+            id: m.id,
+            number: m.iid,
+            title: m.title,
+            state: m.state,
+            ...(m.description !== undefined ? { description: m.description } : {}),
+            ...(m.due_date !== undefined ? { dueDate: m.due_date } : {}),
+            ...(m.web_url ? { webUrl: m.web_url } : {}),
+        }));
+    },
+};
+function mapWorkItemSummary(i) {
+    return {
+        id: i.id,
+        number: i.iid,
+        title: i.title,
+        state: mapState(i.state),
+        webUrl: i.web_url,
+        ...(i.description != null ? { description: i.description } : {}),
+        ...(i.labels ? { labels: i.labels } : {}),
+        ...(i.assignees ? { assignees: i.assignees.map((a) => ({ id: a.id, username: a.username, name: a.name })) } : {}),
+        ...(i.author ? { author: { id: i.author.id, username: i.author.username, name: i.author.name } } : {}),
+        ...(i.created_at ? { createdAt: i.created_at } : {}),
+        ...(i.due_date !== undefined ? { dueDate: i.due_date } : {}),
+    };
+}
+// ---- Change requests -------------------------------------------------------
+const gitlabChangeRequests = {
+    async list(repoId, opts = {}) {
+        const mrs = await gitlab.listMergeRequests(repoId, {
+            ...(opts.state ? { state: toGitlabMrState(opts.state) } : {}),
+            ...(opts.search ? { search: opts.search } : {}),
+            ...(opts.sourceBranch ? { sourceBranch: opts.sourceBranch } : {}),
+            ...(opts.page ? { page: opts.page } : {}),
+            ...(opts.perPage ? { perPage: opts.perPage } : {}),
+        });
+        return mrs.map((m) => ({
+            id: m.id,
+            number: m.iid,
+            title: m.title,
+            state: mapState(m.state),
+            webUrl: m.web_url,
+            ...(m.description !== undefined ? { description: m.description } : {}),
+            ...(m.source_branch ? { sourceBranch: m.source_branch } : {}),
+            ...(m.target_branch ? { targetBranch: m.target_branch } : {}),
+            ...(m.labels ? { labels: m.labels } : {}),
+            ...(m.author ? { author: m.author } : {}),
+            ...(m.created_at ? { createdAt: m.created_at } : {}),
+            ...(m.updated_at ? { updatedAt: m.updated_at } : {}),
+            ...(m.merged_at !== undefined ? { mergedAt: m.merged_at } : {}),
+            ...(m.draft !== undefined ? { draft: m.draft } : {}),
+        }));
+    },
+    async create(repoId, input) {
+        const m = await gitlab.createMergeRequest(repoId, {
+            source_branch: input.sourceBranch,
+            target_branch: input.targetBranch,
+            title: input.title,
+            description: input.description,
+            ...(input.assignee ? { assignee_ids: [input.assignee.id] } : {}),
+        });
+        return {
+            id: m.id,
+            number: m.iid,
+            title: input.title,
+            state: mapState(m.state),
+            sourceBranch: m.source_branch,
+            targetBranch: m.target_branch,
+            webUrl: m.web_url,
+        };
+    },
+    async update(repoId, number, input) {
+        const m = await gitlab.updateMergeRequest(repoId, number, input);
+        return {
+            id: m.id,
+            number: m.iid,
+            title: input.title,
+            state: mapState(m.state),
+            sourceBranch: m.source_branch,
+            targetBranch: m.target_branch,
+            webUrl: m.web_url,
+        };
+    },
+    async get(repoId, number) {
+        const m = await read.getMergeRequestFull(repoId, number);
+        return {
+            id: m.id,
+            number: m.iid,
+            title: m.title,
+            state: mapState(m.state),
+            webUrl: m.web_url ?? "",
+            ...(m.description !== undefined ? { description: m.description ?? "" } : {}),
+            ...(m.source_branch ? { sourceBranch: m.source_branch } : {}),
+            ...(m.target_branch ? { targetBranch: m.target_branch } : {}),
+            ...(m.labels ? { labels: m.labels } : {}),
+            ...(m.author ? { author: m.author } : {}),
+            ...(m.created_at ? { createdAt: m.created_at } : {}),
+            ...(m.updated_at ? { updatedAt: m.updated_at } : {}),
+            ...(m.merged_at !== undefined ? { mergedAt: m.merged_at } : {}),
+            ...(m.draft !== undefined ? { draft: m.draft } : {}),
+        };
+    },
+    async listReviewDiscussions(repoId, number, opts = {}) {
+        const ds = await gitlab.listMergeRequestDiscussions(repoId, number, opts);
+        return ds.map((d) => ({
+            id: d.id,
+            ...(d.individual_note !== undefined ? { individualNote: d.individual_note } : {}),
+            notes: d.notes.map((n) => ({
+                id: n.id,
+                body: n.body,
+                ...(n.type !== undefined ? { type: n.type } : {}),
+                ...(n.system !== undefined ? { system: n.system } : {}),
+                ...(n.author ? { author: n.author } : {}),
+                ...(n.created_at ? { createdAt: n.created_at } : {}),
+                ...(n.resolvable !== undefined ? { resolvable: n.resolvable } : {}),
+                ...(n.resolved !== undefined ? { resolved: n.resolved } : {}),
+                ...(n.position !== undefined ? { position: n.position } : {}),
+            })),
+        }));
+    },
+    async listNotes(repoId, number, opts = {}) {
+        const notes = await read.listMergeRequestNotes(repoId, number, opts);
+        return notes.map((n) => ({
+            id: n.id,
+            body: n.body,
+            ...(n.system !== undefined ? { system: n.system } : {}),
+            ...(n.author ? { author: n.author } : {}),
+            ...(n.created_at ? { createdAt: n.created_at } : {}),
+        }));
+    },
+};
+// ---- Repository ------------------------------------------------------------
+const gitlabRepository = {
+    async getRepo(repoId) {
+        return mapRepo(await read.getProjectDetail(repoId));
+    },
+    branchExists: (repoId, branch) => gitlab.branchExists(repoId, branch),
+    firstExistingBranch: (repoId, branches) => gitlab.firstExistingBranch(repoId, branches),
+    async listBranches(repoId, opts = {}) {
+        const bs = await read.listBranches(repoId, opts);
+        return bs.map((b) => ({
+            name: b.name,
+            ...(b.protected !== undefined ? { protected: b.protected } : {}),
+            ...(b.default !== undefined ? { default: b.default } : {}),
+            ...(b.web_url ? { webUrl: b.web_url } : {}),
+        }));
+    },
+    listTree: (repoId, opts = {}) => read.listRepositoryTree(repoId, opts),
+    getFile: (repoId, filePath, ref, maxBytes) => read.getRepositoryFile(repoId, filePath, ref, maxBytes),
+    async listCommits(repoId, opts = {}) {
+        const cs = await read.listCommits(repoId, opts);
+        return cs.map(mapCommit);
+    },
+    async getCommit(repoId, sha) {
+        return mapCommit(await read.getCommit(repoId, sha));
+    },
+    compare: (repoId, from, to) => read.compareRefs(repoId, from, to).then((c) => mapCompare(c)),
+    async listTags(repoId, opts = {}) {
+        const ts = await read.listTags(repoId, opts);
+        return ts.map((t) => ({
+            name: t.name,
+            ...(t.message !== undefined ? { message: t.message } : {}),
+            ...(t.target ? { target: t.target } : {}),
+            ...(t.protected !== undefined ? { protected: t.protected } : {}),
+        }));
+    },
+    async listMembers(repoId, opts = {}) {
+        const ms = await read.listMembers(repoId, opts);
+        return ms.map((m) => ({
+            id: m.id,
+            username: m.username,
+            name: m.name,
+            ...(m.access_level !== undefined ? { permission: accessLevelToPermission(m.access_level) } : {}),
+            ...(m.web_url ? { webUrl: m.web_url } : {}),
+        }));
+    },
+    async listReleases(repoId, opts = {}) {
+        const rs = await read.listReleases(repoId, opts);
+        return rs.map((r) => ({
+            tagName: r.tag_name,
+            ...(r.name ? { name: r.name } : {}),
+            ...(r.description !== undefined ? { description: r.description } : {}),
+            ...(r.created_at ? { createdAt: r.created_at } : {}),
+            ...(r.released_at ? { releasedAt: r.released_at } : {}),
+            ...(r.author ? { author: r.author } : {}),
+        }));
+    },
+    async listWikiPages(repoId, opts = {}) {
+        const ws = await read.listWikiPages(repoId, opts);
+        return ws.map(mapWiki);
+    },
+    async getWikiPage(repoId, slug) {
+        return mapWiki(await read.getWikiPage(repoId, slug));
+    },
+    searchProject: (repoId, search, opts = {}) => read.searchProject(repoId, search, {
+        ...opts,
+        ...(opts.scope ? { scope: GITLAB_SEARCH_SCOPE[opts.scope] ?? opts.scope } : {}),
+    }),
+};
+function mapCommit(c) {
+    return {
+        id: c.id,
+        title: c.title,
+        ...(c.short_id ? { shortId: c.short_id } : {}),
+        ...(c.message !== undefined ? { message: c.message } : {}),
+        ...(c.author_name ? { authorName: c.author_name } : {}),
+        ...(c.authored_date ? { authoredDate: c.authored_date } : {}),
+        ...(c.created_at ? { createdAt: c.created_at } : {}),
+        ...(c.web_url ? { webUrl: c.web_url } : {}),
+    };
+}
+function mapCompare(c) {
+    return {
+        ...(c.commit ? { commit: { id: c.commit.id, ...(c.commit.short_id ? { shortId: c.commit.short_id } : {}), ...(c.commit.title ? { title: c.commit.title } : {}) } } : {}),
+        commits: c.commits.map((x) => ({
+            id: x.id,
+            ...(x.short_id ? { shortId: x.short_id } : {}),
+            ...(x.title ? { title: x.title } : {}),
+            ...(x.author_name ? { authorName: x.author_name } : {}),
+            ...(x.created_at ? { createdAt: x.created_at } : {}),
+        })),
+        ...(c.diffs
+            ? {
+                diffs: c.diffs.map((d) => ({
+                    oldPath: d.old_path,
+                    newPath: d.new_path,
+                    ...(d.diff ? { diff: d.diff } : {}),
+                    ...(d.new_file !== undefined ? { newFile: d.new_file } : {}),
+                    ...(d.renamed_file !== undefined ? { renamedFile: d.renamed_file } : {}),
+                    ...(d.deleted_file !== undefined ? { deletedFile: d.deleted_file } : {}),
+                    ...(d.too_large !== undefined ? { tooLarge: d.too_large } : {}),
+                })),
+            }
+            : {}),
+    };
+}
+function mapWiki(w) {
+    return {
+        slug: w.slug,
+        title: w.title,
+        ...(w.format ? { format: w.format } : {}),
+        ...(w.content !== undefined ? { content: w.content } : {}),
+        ...(w.updated_at ? { updatedAt: w.updated_at } : {}),
+    };
+}
+// ---- CI --------------------------------------------------------------------
+const gitlabCi = {
+    async listPipelines(repoId, opts = {}) {
+        const ps = await read.listPipelines(repoId, opts);
+        return ps.map((p) => ({
+            id: p.id,
+            status: p.status,
+            ...(p.ref ? { ref: p.ref } : {}),
+            ...(p.sha ? { sha: p.sha } : {}),
+            ...(p.name ? { name: p.name } : {}),
+            ...(p.web_url ? { webUrl: p.web_url } : {}),
+            ...(p.created_at ? { createdAt: p.created_at } : {}),
+            ...(p.updated_at ? { updatedAt: p.updated_at } : {}),
+            ...(p.duration !== undefined ? { duration: p.duration } : {}),
+        }));
+    },
+    async getPipeline(repoId, pipelineId) {
+        const p = await read.getPipeline(repoId, pipelineId);
+        return {
+            id: p.id,
+            status: p.status,
+            ...(p.ref ? { ref: p.ref } : {}),
+            ...(p.sha ? { sha: p.sha } : {}),
+            ...(p.name ? { name: p.name } : {}),
+            ...(p.web_url ? { webUrl: p.web_url } : {}),
+            ...(p.created_at ? { createdAt: p.created_at } : {}),
+            ...(p.updated_at ? { updatedAt: p.updated_at } : {}),
+            ...(p.duration !== undefined ? { duration: p.duration } : {}),
+        };
+    },
+    async listPipelineJobs(repoId, pipelineId, opts = {}) {
+        // Neutral `outcome: "failed"` maps to GitLab's server-side scope=failed.
+        const js = await read.listPipelineJobs(repoId, pipelineId, {
+            ...(opts.scope ? { scope: opts.scope } : {}),
+            ...(opts.outcome === "failed" ? { scope: "failed" } : {}),
+            ...(opts.page ? { page: opts.page } : {}),
+            ...(opts.perPage ? { perPage: opts.perPage } : {}),
+        });
+        return js.map((j) => ({
+            id: j.id,
+            name: j.name,
+            status: j.status,
+            ...(j.stage ? { stage: j.stage } : {}),
+            ...(j.ref ? { ref: j.ref } : {}),
+            ...(j.web_url ? { webUrl: j.web_url } : {}),
+            ...(j.created_at ? { createdAt: j.created_at } : {}),
+            ...(j.started_at !== undefined ? { startedAt: j.started_at } : {}),
+            ...(j.finished_at !== undefined ? { finishedAt: j.finished_at } : {}),
+            ...(j.duration !== undefined ? { duration: j.duration } : {}),
+        }));
+    },
+    getJobLog: (repoId, jobId, maxBytes) => read.getJobLog(repoId, jobId, maxBytes),
+};
+// ---- Git auth --------------------------------------------------------------
+const gitlabGitAuth = {
+    gitExtraHeader: () => gitExtraHeaderGitlab(config.PLATFORM_TOKEN),
+    cloneUrl: (path) => `${config.PLATFORM_URL.replace(/\/$/, "")}/${path}.git`,
+};
+// ---- Attachments -----------------------------------------------------------
+const gitlabAttachments = {
+    findRefs: (body) => findAttachmentRefs(body),
+    download: (repoId, ref) => downloadAttachment(repoId, ref),
+    upload: (repoId, _number, file) => uploadAttachment(repoId, file),
+};
+// ---- Onboarding ------------------------------------------------------------
+const gitlabOnboarding = {
+    authorizeUrl: (state) => oauth.getAuthorizationUrl(state),
+    exchangeCode: (code) => oauth.exchangeCodeForToken(code),
+    async currentUser(accessToken) {
+        const u = await oauth.fetchCurrentUser(accessToken);
+        return { id: u.id, username: u.username };
+    },
+    async listProjects(accessToken, q) {
+        const ps = await admin.listAllProjects(accessToken, q);
+        return ps.map((p) => ({ id: p.id, path: p.pathWithNamespace, webUrl: p.webUrl }));
+    },
+    addBot: (accessToken, project) => admin.inviteBotToProject(accessToken, project.id),
+    removeBot: (accessToken, project) => admin.removeBotFromProject(accessToken, project.id),
+    findOrCreateWebhook: (accessToken, project, url, secret) => admin.findOrCreateWebhookForUrl(accessToken, project.id, url, secret),
+    setWebhookSecret: (accessToken, project, webhookId, secret) => admin.updateWebhookToken(accessToken, project.id, webhookId, secret),
+    ensureCiFailureEvents: (accessToken, project, webhookId) => admin.ensureCiFailureEvents(accessToken, project.id, webhookId),
+    deleteWebhook: (accessToken, project, webhookId) => admin.deleteWebhook(accessToken, project.id, webhookId),
+    testWebhook: (accessToken, project, webhookId) => admin.triggerTestWebhook(accessToken, project.id, webhookId),
+};
+// ---- Links -----------------------------------------------------------------
+const gitlabLinks = {
+    workItemUrl(projectPath, number) {
+        if (!projectPath || !Number.isInteger(number) || number <= 0)
+            return "";
+        return `${config.PLATFORM_URL.replace(/\/$/, "")}/${projectPath}/-/work_items/${number}`;
+    },
+};
+// ---- Assembly --------------------------------------------------------------
+export const gitlabPlatform = {
+    name: "gitlab",
+    ingress: gitlabIngress,
+    workItems: gitlabWorkItems,
+    changeRequests: gitlabChangeRequests,
+    repository: gitlabRepository,
+    ci: gitlabCi,
+    gitAuth: gitlabGitAuth,
+    attachments: gitlabAttachments,
+    onboarding: gitlabOnboarding,
+    links: gitlabLinks,
+};
+//# sourceMappingURL=index.js.map