@ipul-labs/forge 1.13.0

package/server/forge/core/providers/gitlab.js

@@ -0,0 +1,529 @@
+/**
+ * server/forge/core/providers/gitlab.js
+ *
+ * GitLab REST API v4 implementation of ScmProvider.
+ *
+ * Required env vars:
+ *   GITLAB_TOKEN          — personal access token
+ *   FORGE_GITLAB_PROJECT  — default project path, e.g. "ipul/web-app"
+ */
+
+import { getConnection } from "../configStore.js";
+import { ScmProvider } from "./base.js";
+
+const CLOSING_ISSUE_RE = /\b(?:Closes|Fixes|Resolves)\s+#(\d+)/gi;
+
+function parseClosingIssueRefs(text) {
+	if (!text) return [];
+	const seen = new Set();
+	for (const m of text.matchAll(CLOSING_ISSUE_RE)) seen.add(Number(m[1]));
+	return [...seen];
+}
+
+export class GitLabProvider extends ScmProvider {
+	/** @param {string} [project] */
+	constructor(project) {
+		super();
+		this._project = project ?? process.env.FORGE_GITLAB_PROJECT;
+	}
+
+	get name() { return "gitlab"; }
+	get supportsRebase() { return true; }
+
+	get _base() {
+		return getConnection("gitlab").baseUrl;
+	}
+
+	// ─── Internal helpers ──────────────────────────────────────────────────────
+
+	_headers() {
+		return {
+			"PRIVATE-TOKEN": getConnection("gitlab").token,
+			"Content-Type": "application/json",
+		};
+	}
+
+	_enc() {
+		return encodeURIComponent(this._project);
+	}
+
+	async _req(path, options = {}) {
+		const res = await fetch(`${this._base}${path}`, {
+			...options,
+			headers: { ...this._headers(), ...options.headers },
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new Error(`GitLab ${res.status} on ${path}: ${text}`);
+		}
+		return res.json();
+	}
+
+	// ─── Normalizers ──────────────────────────────────────────────────────────
+
+	/** @param {object} raw @returns {import('./base.js').NormalIssue} */
+	_issue(raw) {
+		return {
+			iid: raw.iid,
+			title: raw.title,
+			description: raw.description ?? null,
+			labels: raw.labels ?? [],
+			author: { name: raw.author?.name ?? "" },
+			created_at: raw.created_at,
+			web_url: raw.web_url,
+		};
+	}
+
+	/** @param {object} raw @returns {import('./base.js').NormalMR} */
+	_mr(raw) {
+		return {
+			iid: raw.iid,
+			title: raw.title,
+			web_url: raw.web_url,
+			source_branch: raw.source_branch,
+			target_branch: raw.target_branch,
+			state: raw.state,
+			has_conflicts: raw.has_conflicts ?? false,
+			rebase_in_progress: raw.rebase_in_progress ?? false,
+			merge_status: raw.merge_status ?? "",
+			detailed_merge_status: raw.detailed_merge_status ?? null,
+			merge_when_pipeline_succeeds: raw.merge_when_pipeline_succeeds ?? false,
+			draft: raw.draft ?? raw.work_in_progress ?? false,
+			head_pipeline: raw.head_pipeline
+				? { status: raw.head_pipeline.status, web_url: raw.head_pipeline.web_url }
+				: null,
+			author: { name: raw.author?.name ?? "" },
+			created_at: raw.created_at,
+			merged_at: raw.merged_at ?? null,
+			merge_commit_sha: raw.merge_commit_sha ?? null,
+		};
+	}
+
+	/** @param {object} raw @returns {import('./base.js').NormalPipeline} */
+	_pipeline(raw) {
+		return {
+			id: raw.id,
+			status: raw.status,
+			web_url: raw.web_url,
+			created_at: raw.created_at,
+		};
+	}
+
+	/** @param {object} raw @returns {import('./base.js').NormalJob} */
+	_job(raw) {
+		return {
+			id: raw.id,
+			name: raw.name,
+			stage: raw.stage,
+			status: raw.status,
+			web_url: raw.web_url,
+			duration: raw.duration ?? null,
+		};
+	}
+
+	/** @param {object} raw @returns {import('./base.js').NormalDiff} */
+	_diff(raw) {
+		return {
+			old_path: raw.old_path,
+			new_path: raw.new_path,
+			diff: raw.diff ?? "",
+			new_file: raw.new_file ?? false,
+			renamed_file: raw.renamed_file ?? false,
+			deleted_file: raw.deleted_file ?? false,
+		};
+	}
+
+	// ─── Issues ───────────────────────────────────────────────────────────────
+
+	async listOpenIssues() {
+		const raw = await this._req(
+			`/projects/${this._enc()}/issues?state=opened&order_by=updated_at&per_page=25`,
+		);
+		return raw.map((r) => this._issue(r));
+	}
+
+	async getIssue(iid) {
+		const raw = await this._req(`/projects/${this._enc()}/issues/${iid}`);
+		return this._issue(raw);
+	}
+
+	async createIssue(title, description = "") {
+		const raw = await this._req(`/projects/${this._enc()}/issues`, {
+			method: "POST",
+			body: JSON.stringify({ title, description }),
+		});
+		return this._issue(raw);
+	}
+
+	async updateIssue(iid, { title, description }) {
+		const raw = await this._req(`/projects/${this._enc()}/issues/${iid}`, {
+			method: "PUT",
+			body: JSON.stringify({ title, description }),
+		});
+		return this._issue(raw);
+	}
+
+	async closeIssue(iid) {
+		const raw = await this._req(`/projects/${this._enc()}/issues/${iid}`, {
+			method: "PUT",
+			body: JSON.stringify({ state_event: "close" }),
+		});
+		return this._issue(raw);
+	}
+
+	// ─── Repository ───────────────────────────────────────────────────────────
+
+	async getFileTree(srcPath = "src", ref = "main") {
+		const scan = async (pathParam) => {
+			const items = [];
+			let page = 1;
+			while (true) {
+				const batch = await this._req(
+					`/projects/${this._enc()}/repository/tree` +
+					`?${pathParam ? `path=${pathParam}&` : ""}recursive=true&ref=${ref}&per_page=100&page=${page}`,
+				);
+				items.push(...batch);
+				if (batch.length < 100) break;
+				page++;
+			}
+			return items;
+		};
+
+		let allItems;
+		try {
+			allItems = await scan(srcPath);
+		} catch (err) {
+			// The srcPath defaults to "src" but not every repo uses that layout
+			// (Go repos use go/, Python uses app/, etc.). Fall back to full tree.
+			if (/404|invalid revision or path/i.test(err?.message ?? "")) {
+				allItems = await scan("");
+			} else {
+				throw err;
+			}
+		}
+
+		return allItems
+			.filter((item) => item.type === "blob")
+			.filter((item) => /\.(ts|tsx|js|jsx|json|css|yaml|yml|md|go|py|rs|java|rb|sh|toml)$/.test(item.path))
+			.map((item) => item.path);
+	}
+
+	async getFileContent(filePath, ref = "main") {
+		const encoded = encodeURIComponent(filePath);
+		const data = await this._req(
+			`/projects/${this._enc()}/repository/files/${encoded}?ref=${ref}`,
+		);
+		return Buffer.from(data.content, "base64").toString("utf-8");
+	}
+
+	// ─── Mutations ────────────────────────────────────────────────────────────
+
+	async createBranch(branchName, ref = "main") {
+		return this._req(`/projects/${this._enc()}/repository/branches`, {
+			method: "POST",
+			body: JSON.stringify({ branch: branchName, ref }),
+		});
+	}
+
+	async deleteBranch(branchName) {
+		const res = await fetch(
+			`${this._base}/projects/${this._enc()}/repository/branches/${encodeURIComponent(branchName)}`,
+			{ method: "DELETE", headers: this._headers() },
+		);
+		// 404 is fine — branch was already gone.
+		if (!res.ok && res.status !== 404) {
+			const text = await res.text().catch(() => "");
+			throw new Error(`GitLab ${res.status} deleting ${branchName}: ${text}`);
+		}
+	}
+
+	async commitFiles(branch, message, actions) {
+		// GitLab uses "update" where the base interface uses "modify"
+		const mapped = actions.map((a) => ({
+			...a,
+			action: a.action === "modify" ? "update" : a.action,
+		}));
+		const payload = { branch, commit_message: message, actions: mapped };
+		try {
+			return await this._req(`/projects/${this._enc()}/repository/commits`, {
+				method: "POST",
+				body: JSON.stringify(payload),
+			});
+		} catch (err) {
+			// When committing to an existing branch, a file that was previously
+			// created now exists — retry with create→update for all such actions.
+			if (err.message.includes("already exists") && mapped.some((a) => a.action === "create")) {
+				const fixed = mapped.map((a) => ({
+					...a,
+					action: a.action === "create" ? "update" : a.action,
+				}));
+				return this._req(`/projects/${this._enc()}/repository/commits`, {
+					method: "POST",
+					body: JSON.stringify({ ...payload, actions: fixed }),
+				});
+			}
+			throw err;
+		}
+	}
+
+	async createMR({ sourceBranch, targetBranch = "main", title, description = "", labels = [] }) {
+		const body = {
+			source_branch: sourceBranch,
+			target_branch: targetBranch,
+			title,
+			description,
+			remove_source_branch: true,
+		};
+		if (labels?.length) body.labels = labels.join(",");
+		const raw = await this._req(`/projects/${this._enc()}/merge_requests`, {
+			method: "POST",
+			body: JSON.stringify(body),
+		});
+		return this._mr(raw);
+	}
+
+	// ─── MR / PR queries ──────────────────────────────────────────────────────
+
+	async listAllForgeMRs(state = "open") {
+		const gitlabState = state === "open" ? "opened" : state;
+		const all = await this._req(
+			`/projects/${this._enc()}/merge_requests?state=${gitlabState}&per_page=50`,
+		);
+		const forge = all.filter((mr) => mr.source_branch?.startsWith("forge/"));
+		// Only open MRs need the head_pipeline detail fetch — merged/closed rows
+		// don't render a live pipeline badge in the UI.
+		if (state !== "open") return forge.map((mr) => this._mr(mr));
+		const detailed = await Promise.all(
+			forge.map((mr) => this._req(`/projects/${this._enc()}/merge_requests/${mr.iid}`)),
+		);
+		return detailed.map((mr) => this._mr(mr));
+	}
+
+	async listForgeMRsForIssue(issueIid) {
+		const all = await this._req(
+			`/projects/${this._enc()}/merge_requests?state=opened&per_page=50`,
+		);
+		return all
+			.filter((mr) => mr.source_branch?.startsWith(`forge/issue-${issueIid}-`))
+			.map((mr) => this._mr(mr));
+	}
+
+	async listMergedForgeMRsForIssue(issueIid) {
+		const all = await this._req(
+			`/projects/${this._enc()}/merge_requests?state=merged&per_page=50`,
+		);
+		return all
+			.filter((mr) => mr.source_branch?.startsWith(`forge/issue-${issueIid}-`))
+			.map((mr) => this._mr(mr));
+	}
+
+	async getMR(mrIid) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}`,
+		);
+		return this._mr(raw);
+	}
+
+	async getMRDiffs(mrIid) {
+		const allDiffs = [];
+		let page = 1;
+		while (true) {
+			const items = await this._req(
+				`/projects/${this._enc()}/merge_requests/${mrIid}/diffs?per_page=20&page=${page}`,
+			);
+			allDiffs.push(...items);
+			if (items.length < 20) break;
+			page++;
+		}
+		return allDiffs.map((d) => this._diff(d));
+	}
+
+	async rebaseMR(mrIid) {
+		await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}/rebase`,
+			{ method: "PUT" },
+		);
+	}
+
+	async setAutoMergeMR(mrIid) {
+		await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}/merge`,
+			{ method: "PUT", body: JSON.stringify({ merge_when_pipeline_succeeds: true }) },
+		);
+	}
+
+	async cancelAutoMergeMR(mrIid) {
+		await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}/cancel_merge_when_pipeline_succeeds`,
+			{ method: "POST" },
+		);
+	}
+
+	async mergeMR(mrIid) {
+		await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}/merge`,
+			{ method: "PUT", body: JSON.stringify({ should_remove_source_branch: true }) },
+		);
+	}
+
+	async closeMR(mrIid) {
+		await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}`,
+			{ method: "PUT", body: JSON.stringify({ state_event: "close" }) },
+		);
+	}
+
+	async reopenMR(mrIid) {
+		await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}`,
+			{ method: "PUT", body: JSON.stringify({ state_event: "reopen" }) },
+		);
+	}
+
+	async setMRDraft(mrIid, draft) {
+		// GitLab marks an MR as draft by prefixing the title with "Draft: ".
+		// Fetch, adjust, and write back — the update endpoint has no boolean flag.
+		const current = await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}`,
+		);
+		const title = String(current.title ?? "");
+		const stripped = title.replace(/^(Draft:|WIP:)\s*/i, "");
+		const nextTitle = draft ? `Draft: ${stripped}` : stripped;
+		if (nextTitle === title) return;
+		await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}`,
+			{ method: "PUT", body: JSON.stringify({ title: nextTitle }) },
+		);
+	}
+
+	// ─── CI / Pipelines ───────────────────────────────────────────────────────
+
+	async getMRPipelines(mrIid) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/merge_requests/${mrIid}/pipelines`,
+		);
+		return raw.map((p) => this._pipeline(p));
+	}
+
+	async getPipeline(pipelineId) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/pipelines/${pipelineId}`,
+		);
+		return this._pipeline(raw);
+	}
+
+	async getPipelineJobs(pipelineId) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/pipelines/${pipelineId}/jobs`,
+		);
+		return raw.map((j) => this._job(j));
+	}
+
+	async getJobTrace(jobId) {
+		const url = `${this._base}/projects/${this._enc()}/jobs/${jobId}/trace`;
+		const res = await fetch(url, { headers: this._headers() });
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new Error(`GitLab ${res.status} on jobs/${jobId}/trace: ${text}`);
+		}
+		return res.text();
+	}
+
+	// ─── GitLab-specific extras ───────────────────────────────────────────────
+
+	async getPipelinesBySha(sha) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/pipelines?sha=${encodeURIComponent(sha)}&per_page=5`,
+		);
+		return raw.map((p) => this._pipeline(p));
+	}
+
+	async getPipelinesByRef(ref) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/pipelines?ref=${encodeURIComponent(ref)}&per_page=5`,
+		);
+		return raw.map((p) => this._pipeline(p));
+	}
+
+	async listBranchesByPrefix(prefix) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/repository/branches?search=^${encodeURIComponent(prefix)}&per_page=100`,
+		);
+		return raw.map((b) => b.name).filter((n) => n.startsWith(prefix));
+	}
+
+	async compareRefs(fromRef, toRef) {
+		try {
+			const raw = await this._req(
+				`/projects/${this._enc()}/repository/compare?from=${encodeURIComponent(fromRef)}&to=${encodeURIComponent(toRef)}&straight=true`,
+			);
+			return { aheadCount: Array.isArray(raw.commits) ? raw.commits.length : 0 };
+		} catch {
+			return null;
+		}
+	}
+
+	async listRecentMergedMRIssueLinks(limit = 50) {
+		const raw = await this._req(
+			`/projects/${this._enc()}/merge_requests?state=merged&order_by=updated_at&per_page=${limit}`,
+		);
+		// Don't pre-filter on `closedIssueIids` — the route uses `sourceBranch`
+		// as a fallback signal when the MR description lacks a closing keyword.
+		return raw.map((mr) => ({
+			mrIid: mr.iid,
+			webUrl: mr.web_url,
+			mergedAt: mr.merged_at ?? null,
+			sourceBranch: mr.source_branch ?? null,
+			closedIssueIids: parseClosingIssueRefs(mr.description ?? ""),
+		}));
+	}
+
+	// ─── Environments ─────────────────────────────────────────────────────────
+
+	/** @param {object} raw @returns {import('./base.js').NormalEnvironment} */
+	_environment(raw) {
+		return {
+			id: raw.id,
+			name: raw.name,
+			state: raw.state ?? "unknown",
+			external_url: raw.external_url ?? null,
+			// GitLab puts the branch ref on the last deployment's deployable.
+			ref: raw.last_deployment?.deployable?.ref
+				?? raw.last_deployment?.ref
+				?? null,
+			updated_at: raw.updated_at ?? null,
+			web_url: raw.web_url ?? null,
+		};
+	}
+
+	/**
+	 * Pull environments for a given branch. GitLab's `/environments` endpoint
+	 * doesn't filter by ref, so we fetch available+stopping envs and match on
+	 * the last-deployment ref. Limits per_page to 100 — ephemeral envs should
+	 * never grow past that per project.
+	 */
+	async listEnvironmentsForBranch(branchName) {
+		if (!branchName) return [];
+		const raw = await this._req(
+			`/projects/${this._enc()}/environments?states=available&per_page=100`,
+		);
+		// GitLab's list response omits last_deployment — fetch detail per-env to
+		// learn the branch. Concurrency is bounded by the per_page=100 cap.
+		const detailed = await Promise.all(
+			raw.map((e) =>
+				this._req(`/projects/${this._enc()}/environments/${e.id}`).catch(() => null),
+			),
+		);
+		return detailed
+			.filter(Boolean)
+			.map((e) => this._environment(e))
+			.filter((e) => e.ref === branchName);
+	}
+
+	async stopEnvironment(envId) {
+		await this._req(
+			`/projects/${this._enc()}/environments/${envId}/stop`,
+			{ method: "POST" },
+		);
+	}
+}

package/server/forge/core/providers/index.js

@@ -0,0 +1,47 @@
+/**
+ * server/forge/core/providers/index.js
+ *
+ * Factory that creates the correct ScmProvider for a given repo string.
+ * Provider type is resolved in this order:
+ *   1. Per-repo prefix  — "github:owner/repo", "azuredevops:org/project/repo"
+ *   2. SCM_PROVIDER env var — "gitlab" | "github" | "azuredevops"
+ *   3. Default: gitlab
+ */
+
+import { GitLabProvider } from "./gitlab.js";
+import { GitHubProvider } from "./github.js";
+import { AzureDevOpsProvider } from "./azuredevops.js";
+
+/**
+ * @param {string} [repo]  Raw repo string from request (may carry a "type:" prefix)
+ * @returns {import('./base.js').ScmProvider}
+ */
+export function createProvider(repo) {
+	// Strip optional "provider:" prefix, e.g. "github:owner/repo"
+	let type = process.env.SCM_PROVIDER ?? "gitlab";
+	let repoPath = repo;
+
+	if (repo) {
+		const colonIdx = repo.indexOf(":");
+		if (colonIdx > 0) {
+			const prefix = repo.slice(0, colonIdx).toLowerCase();
+			if (["gitlab", "github", "azuredevops"].includes(prefix)) {
+				type = prefix;
+				repoPath = repo.slice(colonIdx + 1);
+			}
+		}
+	}
+
+	switch (type.toLowerCase()) {
+		case "github":
+			return new GitHubProvider(repoPath);
+		case "azuredevops":
+		case "azure":
+			return new AzureDevOpsProvider(repoPath);
+		default:
+			return new GitLabProvider(repoPath);
+	}
+}
+
+export { GitLabProvider, GitHubProvider, AzureDevOpsProvider };
+export { ScmProvider } from "./base.js";

package/server/forge/core/quotaClient.js

@@ -0,0 +1,101 @@
+/**
+ * server/forge/core/quotaClient.js
+ *
+ * One-off probe of the Anthropic Messages API to read the plan-level
+ * rate-limit headers. Used by the "Refresh quota" button in the UsageWidget.
+ *
+ * The rest of Forge still runs through `claude` CLI (subscription billing);
+ * this probe is the only place that spends API credits, and only when the
+ * user explicitly asks for it. Cost is negligible — one request with
+ * `max_tokens=1` against Haiku.
+ */
+
+const PROBE_MODEL = "claude-haiku-4-5-20251001";
+
+function num(v) {
+	const n = Number(v);
+	return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * @param {Headers} headers
+ * @returns {null | {
+ *   tokensLimit: number|null,
+ *   tokensRemaining: number|null,
+ *   tokensReset: string|null,
+ *   requestsLimit: number|null,
+ *   requestsRemaining: number|null,
+ *   requestsReset: string|null,
+ * }}
+ */
+export function parseRateLimit(headers) {
+	const rl = {
+		tokensLimit:       num(headers.get("anthropic-ratelimit-tokens-limit")),
+		tokensRemaining:   num(headers.get("anthropic-ratelimit-tokens-remaining")),
+		tokensReset:       headers.get("anthropic-ratelimit-tokens-reset") ?? null,
+		requestsLimit:     num(headers.get("anthropic-ratelimit-requests-limit")),
+		requestsRemaining: num(headers.get("anthropic-ratelimit-requests-remaining")),
+		requestsReset:     headers.get("anthropic-ratelimit-requests-reset") ?? null,
+	};
+	const any =
+		rl.tokensLimit !== null ||
+		rl.tokensRemaining !== null ||
+		rl.tokensReset ||
+		rl.requestsLimit !== null ||
+		rl.requestsRemaining !== null ||
+		rl.requestsReset;
+	return any ? rl : null;
+}
+
+/**
+ * Fires one minimal Messages API request and returns the rate-limit snapshot
+ * from the response headers.
+ *
+ * @throws if ANTHROPIC_API_KEY is not configured, or the API rejects us.
+ */
+export async function probeQuota() {
+	if (!process.env.ANTHROPIC_API_KEY) {
+		const err = new Error(
+			"Quota check requires ANTHROPIC_API_KEY to be set. Add it to your .env.",
+		);
+		err.status = 400;
+		throw err;
+	}
+
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), 10_000);
+
+	let res;
+	try {
+		res = await fetch("https://api.anthropic.com/v1/messages", {
+			method: "POST",
+			headers: {
+				"x-api-key": process.env.ANTHROPIC_API_KEY,
+				"anthropic-version": "2023-06-01",
+				"content-type": "application/json",
+			},
+			body: JSON.stringify({
+				model: PROBE_MODEL,
+				max_tokens: 1,
+				messages: [{ role: "user", content: "." }],
+			}),
+			signal: controller.signal,
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+
+	// Rate-limit headers are present even on 4xx/5xx responses, so grab them
+	// before deciding whether to throw.
+	const rateLimit = parseRateLimit(res.headers);
+
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		const err = new Error(`Anthropic API ${res.status}: ${text.slice(0, 300)}`);
+		err.status = res.status;
+		err.rateLimit = rateLimit;
+		throw err;
+	}
+
+	return { rateLimit, checkedAt: new Date().toISOString() };
+}