@remogram/provider-gitea-api 0.1.0-beta.8 → 0.1.0-beta.9

package/branch-protection-internal.js

@@ -0,0 +1,13 @@
+/** @type {((ctx: object, opts: { branchRef: string }) => Promise<object>) | null} */
+let branchProtectionImpl = null;
+
+export function setBranchProtectionImpl(fn) {
+  branchProtectionImpl = fn;
+}
+
+export async function resolveBranchProtection(ctx, opts) {
+  if (typeof branchProtectionImpl !== 'function') {
+    throw new Error('branch protection impl not registered');
+  }
+  return branchProtectionImpl(ctx, opts);
+}

package/index.js

@@ -12,11 +12,15 @@ import {
   crInventory,
   buildMergePlanFromProviderFacts,
   buildChangeRequestOpenedBody,
+  buildIssueOpenedBody,
+  parseIssueOpenArgs,
   buildCommitStatusSetBody,
+  idempotencyPacketFields,
   parseStatusSetArgs,
   normalizeStatusSetState,
   buildProviderIdentityFromGiteaUser,
   buildBranchProtectionFromGiteaProtection,
+  buildPrChecksBody,
   buildCrFilesBody,
   buildCrFilesFromGiteaFiles,
   buildCrCommentsBody,
@@ -28,6 +32,7 @@ import {
   ERROR_CODES,
   forgeError,
   assertExpectedSha,
+  LIVE_REACHABILITY_TIMEOUT_MS,
   forgeIngestCapabilityFacts,
   checkPaginationCapabilityFacts,
   idempotencyScanCapabilityFacts,
@@ -58,7 +63,14 @@ import {
   giteaOpenPullSortQuery,
   appendSortQuery,
   assertWriteCommandConfigured,
+  fetchWithTimeout,
+  readStreamCapped,
+  getEffectiveIngestMaxBytes,
 } from '@remogram/core';
+import {
+  resolveBranchProtection,
+  setBranchProtectionImpl,
+} from './branch-protection-internal.js';
 const PUBLIC_GITEA_HOST = 'gitea.com';
 const PUBLIC_GITEA_API = 'https://gitea.com/api/v1';
 const AUTH_CAPABILITIES = [
@@ -81,6 +93,7 @@ const AUTH_CAPABILITIES = [
 
 const STRUCTURED_COMMANDS = apiProviderCommands({
   writeCommandsImplemented: true,
+  issueOpenImplemented: true,
   statusSetImplemented: true,
   branchProtectionImplemented: true,
   crFilesImplemented: true,
@@ -215,6 +228,22 @@ export async function giteaFetchWithMeta(config, parsed, path, options = {}) {
   });
 }
 
+export async function apiReachability(ctx) {
+  if (!giteaToken()) {
+    throw Object.assign(new Error('GITEA_TOKEN not set'), {
+      forgeError: forgeError(ERROR_CODES.UNAUTHENTICATED_PROVIDER, 'GITEA_TOKEN not set'),
+    });
+  }
+  const token = requireToken();
+  const url = `${apiBase(ctx.config, ctx.parsed)}${repoApiPath(ctx.config)}`;
+  await fetchJson(
+    url,
+    { headers: authHeaders(token) },
+    LIVE_REACHABILITY_TIMEOUT_MS,
+  );
+  return { repo_accessible: true };
+}
+
 const MAX_CHECK_PAGES = MAX_CHECK_STATUS_PAGES;
 const GITEA_PAGE_SIZE = DEFAULT_OPEN_PULL_LIST_PAGE_SIZE;
 
@@ -281,11 +310,14 @@ export function dedupeGiteaStatusRecords(records) {
   return Array.from(latestByContext.values());
 }
 
-export function mapGiteaCommitStatuses(records) {
+export function mapGiteaCommitStatuses(records, { headSha } = {}) {
   return dedupeGiteaStatusRecords(records).map((s) => ({
     context: sanitizeField(s.context),
     state: normalizeGiteaStatusState(s.status ?? s.state),
     description: sanitizeField(s.description),
+    ...(s.target_url ? { target_url: sanitizeField(s.target_url) } : {}),
+    ...(headSha ? { sha: headSha } : {}),
+    source: 'commit_status',
   }));
 }
 
@@ -319,12 +351,19 @@ export async function whoami(ctx) {
 
 export async function branchProtection(ctx, { branchRef }) {
   requireToken();
-  const protection = await giteaFetch(
-    ctx.config,
-    ctx.parsed,
-    repoApiPath(ctx.config, 'branch_protections', branchRef),
-  );
-  return buildBranchProtectionFromGiteaProtection(branchRef, protection);
+  try {
+    const protection = await giteaFetch(
+      ctx.config,
+      ctx.parsed,
+      repoApiPath(ctx.config, 'branch_protections', branchRef),
+    );
+    return buildBranchProtectionFromGiteaProtection(branchRef, protection);
+  } catch (err) {
+    if (err?.status === 404) {
+      return buildBranchProtectionFromGiteaProtection(branchRef, null);
+    }
+    throw err;
+  }
 }
 
 export async function branchHeadSha(ctx, branchRef, { repoId } = {}) {
@@ -551,7 +590,7 @@ export function providerCapabilities() {
     host_binding: 'verified_remote_host',
     pagination: 'supported',
     write_support: true,
-    write_commands: ['cr_open', 'status_set', 'merge'],
+    write_commands: ['cr_open', 'status_set', 'merge', 'issue_open'],
     ...forgeIngestCapabilityFacts(),
     ...checkPaginationCapabilityFacts({
       strategy: 'offset_limit',
@@ -600,7 +639,63 @@ export async function getPull(ctx, { number }) {
       forgeError: forgeError(ERROR_CODES.INVALID_ARGS, 'Provide --number for PR lookup'),
     });
   }
-  return giteaFetch(ctx.config, ctx.parsed, repoApiPath(ctx.config, 'pulls', number));
+  return giteaFetchPullForView(ctx.config, ctx.parsed, number);
+}
+
+/** Raw read bound for pull view before stripping bulky fields (#478). */
+const GITEA_PULL_VIEW_RAW_READ_MAX = 256 * 1024;
+
+function stripGiteaPullBulkJsonFields(raw) {
+  return String(raw)
+    .replace(/"body"\s*:\s*"(?:\\.|[^"\\])*"/g, '"body":""')
+    .replace(/"body_html"\s*:\s*"(?:\\.|[^"\\])*"/g, '"body_html":""')
+    .replace(/"diff"\s*:\s*"(?:\\.|[^"\\])*"/g, '"diff":""')
+    .replace(/"patch"\s*:\s*"(?:\\.|[^"\\])*"/g, '"patch":""');
+}
+
+async function giteaFetchPullForView(config, parsed, number) {
+  const token = requireToken();
+  const url = `${apiBase(config, parsed)}${repoApiPath(config, 'pulls', number)}`;
+  const res = await fetchWithTimeout(url, { headers: authHeaders(token) });
+  if (res.status >= 300 && res.status < 400) {
+    const message = 'HTTP redirect rejected';
+    throw Object.assign(new Error(message), {
+      forgeError: forgeError(ERROR_CODES.API_ERROR, message, res.status),
+      status: res.status,
+    });
+  }
+  const capped = await readStreamCapped(res.body, GITEA_PULL_VIEW_RAW_READ_MAX);
+  if (capped.truncated) {
+    throw Object.assign(new Error('Provider output exceeded cap'), {
+      forgeError: forgeError(ERROR_CODES.OVERSIZED_RAW_OUTPUT, 'Provider response exceeded byte cap'),
+      status: res.status,
+    });
+  }
+  const stripped = stripGiteaPullBulkJsonFields(capped.text);
+  if (Buffer.byteLength(stripped, 'utf8') > getEffectiveIngestMaxBytes().bytes) {
+    throw Object.assign(new Error('Provider output exceeded cap after projection'), {
+      forgeError: forgeError(ERROR_CODES.OVERSIZED_RAW_OUTPUT, 'Provider response exceeded byte cap'),
+      status: res.status,
+    });
+  }
+  let body;
+  try {
+    body = stripped ? JSON.parse(stripped) : null;
+  } catch {
+    throw Object.assign(new Error('Unparseable JSON from provider'), {
+      forgeError: forgeError(ERROR_CODES.UNPARSEABLE_PROVIDER_OUTPUT, 'Provider returned invalid JSON'),
+      status: res.status,
+    });
+  }
+  if (!res.ok) {
+    const raw = body?.message || body?.error || res.statusText || 'API error';
+    const message = sanitizeField(raw) || 'API error';
+    throw Object.assign(new Error(message), {
+      forgeError: forgeError(ERROR_CODES.API_ERROR, message, res.status),
+      status: res.status,
+    });
+  }
+  return body;
 }
 
 /** Paginated open-pull scan for idempotent cr open; fail-closed when scan cap prevents proof of absence. */
@@ -651,6 +746,68 @@ export async function findOpenPullByHeadBase(ctx, head, base) {
   return null;
 }
 
+function issueOpenIdempotencyScanIncompleteError(pagesScanned, pageSizeUsed) {
+  return forgeError(
+    ERROR_CODES.IDEMPOTENCY_SCAN_INCOMPLETE,
+    'Cannot prove no open issue exists for title within scan limit; retry or open manually',
+    null,
+    {
+      idempotency_scan: {
+        pages: pagesScanned,
+        max_pages: MAX_OPEN_PULL_IDEMPOTENCY_PAGES,
+        page_size: pageSizeUsed,
+      },
+    },
+  );
+}
+
+/** Paginated open-issue scan for idempotent issue open; fail-closed when scan cap prevents proof of absence. */
+export async function findOpenIssueByTitle(ctx, title) {
+  requireToken();
+  const path = `${repoApiPath(ctx.config, 'issues')}?state=open`;
+  const pageSep = path.includes('?') ? '&' : '?';
+  let activeLimit = GITEA_PAGE_SIZE;
+
+  for (let page = 1; page <= MAX_OPEN_PULL_IDEMPOTENCY_PAGES; page += 1) {
+    const { items, usedLimit } = await fetchPageWithIngestBackoff(
+      async ({ page: pageNum, limit }) => {
+        const body = await giteaFetch(
+          ctx.config,
+          ctx.parsed,
+          `${path}${pageSep}limit=${limit}&page=${pageNum}`,
+        );
+        if (!Array.isArray(body)) {
+          throw Object.assign(new Error('Provider returned non-array open issue list'), {
+            forgeError: forgeError(
+              ERROR_CODES.UNPARSEABLE_PROVIDER_OUTPUT,
+              'Provider returned non-array open issue list',
+            ),
+          });
+        }
+        return body;
+      },
+      page,
+      activeLimit,
+    );
+    activeLimit = usedLimit;
+
+    const match =
+      items.find(
+        (issue) =>
+          String(issue?.state ?? '').toLowerCase() === 'open' &&
+          sanitizeField(issue?.title ?? '') === title,
+      ) ?? null;
+    if (match) return match;
+    if (items.length < usedLimit) return null;
+    if (page === MAX_OPEN_PULL_IDEMPOTENCY_PAGES) {
+      throw Object.assign(new Error('Open issue idempotency scan incomplete'), {
+        forgeError: issueOpenIdempotencyScanIncompleteError(page, usedLimit),
+      });
+    }
+  }
+  return null;
+}
+
 function statusSetIdempotencyScanIncompleteError(pagesScanned, pageSizeUsed) {
   return forgeError(
     ERROR_CODES.IDEMPOTENCY_SCAN_INCOMPLETE,
@@ -716,12 +873,18 @@ export async function findCommitStatusByContext(ctx, sha, context) {
 
 export async function statusSet(ctx, args) {
   assertWriteCommandConfigured(ctx.config, 'status_set');
-  const parsed = parseStatusSetArgs(args);
+  const { idempotencyFingerprint = null, ...rest } = args;
+  const parsed = parseStatusSetArgs(rest);
   const existing = await findCommitStatusByContext(ctx, parsed.sha, parsed.context);
   if (existing) {
     const existingState = normalizeStatusSetState(existing.status ?? existing.state);
     if (existingState === parsed.state) {
-      return buildCommitStatusSetBody(existing, parsed, { reusedExisting: true });
+      return buildCommitStatusSetBody(existing, parsed, {
+        reusedExisting: true,
+        idempotencyFields: idempotencyFingerprint
+          ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: true })
+          : null,
+      });
     }
   }
   const payload = {
@@ -740,10 +903,48 @@ export async function statusSet(ctx, args) {
       body: JSON.stringify(payload),
     },
   );
-  return buildCommitStatusSetBody(response, parsed);
+  return buildCommitStatusSetBody(response, parsed, {
+    idempotencyFields: idempotencyFingerprint
+      ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: false })
+      : null,
+  }  );
 }
 
-export async function crOpen(ctx, { head, base, title, body: prBody }) {
+export async function issueOpen(ctx, { title, body: issueBody, idempotencyFingerprint = null }) {
+  assertWriteCommandConfigured(ctx.config, 'issue_open');
+  const parsed = parseIssueOpenArgs({ title, body: issueBody });
+  const existing = await findOpenIssueByTitle(ctx, parsed.title);
+  if (existing) {
+    return buildIssueOpenedBody(
+      existing,
+      { title: parsed.title },
+      {
+        reusedExisting: true,
+        idempotencyFields: idempotencyFingerprint
+          ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: true })
+          : null,
+      },
+    );
+  }
+  const payload = { title: parsed.title };
+  if (parsed.body != null) payload.body = parsed.body;
+  const issue = await giteaFetch(ctx.config, ctx.parsed, repoApiPath(ctx.config, 'issues'), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+  return buildIssueOpenedBody(
+    issue,
+    { title: parsed.title },
+    {
+      idempotencyFields: idempotencyFingerprint
+        ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: false })
+        : null,
+    },
+  );
+}
+
+export async function crOpen(ctx, { head, base, title, body: prBody, idempotencyFingerprint = null }) {
   assertWriteCommandConfigured(ctx.config, 'cr_open');
   assertGitRef(head, 'head');
   assertGitRef(base, 'base');
@@ -762,14 +963,31 @@ export async function crOpen(ctx, { head, base, title, body: prBody }) {
   }
   const existing = await findOpenPullByHeadBase(ctx, payload.head, payload.base);
   if (existing) {
-    return buildChangeRequestOpenedBody(existing, { head, base, title }, { reusedExisting: true });
+    return buildChangeRequestOpenedBody(
+      existing,
+      { head, base, title },
+      {
+        reusedExisting: true,
+        idempotencyFields: idempotencyFingerprint
+          ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: true })
+          : null,
+      },
+    );
   }
   const pull = await giteaFetch(ctx.config, ctx.parsed, repoApiPath(ctx.config, 'pulls'), {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(payload),
   });
-  return buildChangeRequestOpenedBody(pull, { head, base, title });
+  return buildChangeRequestOpenedBody(
+    pull,
+    { head, base, title },
+    {
+      idempotencyFields: idempotencyFingerprint
+        ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: false })
+        : null,
+    },
+  );
 }
 
 export async function mergeExecute(ctx, { number, method = 'merge', expectedHeadSha }) {
@@ -1053,6 +1271,7 @@ export async function prView(ctx, opts) {
 export async function prChecks(ctx, opts) {
   requireToken();
   let sha;
+  let requiredContexts = [];
   if (opts.ref) {
     assertGitRef(opts.ref, 'ref');
     sha = gitRevParse(ctx.cwd, opts.ref);
@@ -1064,6 +1283,15 @@ export async function prChecks(ctx, opts) {
   } else {
     const pr = await getPull(ctx, opts);
     sha = pr.head?.sha;
+    const targetBranch = pr.base?.ref;
+    if (targetBranch) {
+      try {
+        const protection = await resolveBranchProtection(ctx, { branchRef: targetBranch });
+        requiredContexts = protection.required_status_contexts ?? [];
+      } catch (err) {
+        if (err?.status !== 404) throw err;
+      }
+    }
   }
   if (!sha) {
     throw Object.assign(new Error('No SHA'), {
@@ -1075,14 +1303,14 @@ export async function prChecks(ctx, opts) {
     ctx.parsed,
     repoApiPath(ctx.config, 'commits', sha, 'statuses'),
   );
-  const mapped = mapGiteaCommitStatuses(statusRecords);
-  const conclusion = summarizeChecks(mapped);
-  return {
+  const mapped = mapGiteaCommitStatuses(statusRecords, { headSha: sha });
+  return buildPrChecksBody({
     forge_source_sha: sha,
-    check_conclusion: conclusion,
+    check_conclusion: summarizeChecks(mapped),
     checks_truncated,
     statuses: mapped,
-  };
+    required_contexts: requiredContexts,
+  });
 }
 
 export function summarizeChecks(statuses) {
@@ -1127,6 +1355,7 @@ export async function syncPlan(ctx, remoteName = 'origin') {
 export const provider = {
   id: 'gitea-api',
   providerCapabilities,
+  apiReachability,
   repoStatus,
   refsCompare,
   refsInventory,
@@ -1137,6 +1366,7 @@ export const provider = {
   mergePlan,
   syncPlan,
   crOpen,
+  issueOpen,
   mergeExecute,
   statusSet,
   whoami,
@@ -1146,3 +1376,5 @@ export const provider = {
   crComments,
   forgeChanges,
 };
+
+setBranchProtectionImpl(branchProtection);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remogram/provider-gitea-api",
-  "version": "0.1.0-beta.8",
+  "version": "0.1.0-beta.9",
   "description": "Gitea REST API forge provider for remogram",
   "type": "module",
   "license": "MIT",
@@ -16,12 +16,13 @@
     "*.js"
   ],
   "exports": {
-    ".": "./index.js"
+    ".": "./index.js",
+    "./branch-protection-internal.js": "./branch-protection-internal.js"
   },
   "engines": {
     "node": ">=20"
   },
   "dependencies": {
-    "@remogram/core": "0.1.0-beta.8"
+    "@remogram/core": "0.1.0-beta.9"
   }
 }