@teambit/ci 1.0.507 → 1.0.508

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/ci",
-  "version": "1.0.507",
+  "version": "1.0.508",
   "homepage": "https://bit.cloud/teambit/git/ci",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.git",
     "name": "ci",
-    "version": "1.0.507"
+    "version": "1.0.508"
   },
   "dependencies": {
     "chalk": "4.1.2",
@@ -28,19 +28,19 @@
     "@teambit/legacy.scope": "0.0.148",
     "@teambit/legacy.bit-map": "0.0.205",
     "@teambit/toolbox.crypto.sha1": "0.0.20",
-    "@teambit/cli": "0.0.1370",
-    "@teambit/logger": "0.0.1463",
-    "@teambit/workspace": "1.0.1112",
-    "@teambit/builder": "1.0.1112",
-    "@teambit/checkout": "1.0.1113",
-    "@teambit/config-merger": "0.0.979",
-    "@teambit/dependency-resolver": "1.0.1112",
-    "@teambit/export": "1.0.1112",
-    "@teambit/importer": "1.0.1112",
-    "@teambit/lanes": "1.0.1133",
-    "@teambit/objects": "0.0.619",
-    "@teambit/snapping": "1.0.1112",
-    "@teambit/status": "1.0.1137"
+    "@teambit/cli": "0.0.1371",
+    "@teambit/logger": "0.0.1464",
+    "@teambit/workspace": "1.0.1113",
+    "@teambit/builder": "1.0.1113",
+    "@teambit/checkout": "1.0.1114",
+    "@teambit/config-merger": "0.0.980",
+    "@teambit/dependency-resolver": "1.0.1113",
+    "@teambit/export": "1.0.1113",
+    "@teambit/importer": "1.0.1113",
+    "@teambit/lanes": "1.0.1134",
+    "@teambit/objects": "0.0.620",
+    "@teambit/snapping": "1.0.1113",
+    "@teambit/status": "1.0.1138"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",

package/sync/git-host-provider.ts

@@ -33,6 +33,14 @@ export interface GitHostProvider {
   comment(prNumber: number, body: string): Promise<void>;
 
   addLabel(prNumber: number, label: string): Promise<void>;
+
+  /**
+   * Update the comment containing `marker` in place, or post a new one when none exists yet
+   * (`options.createIfAbsent` defaults to true). Optional: a provider that doesn't implement this
+   * is treated as not supporting the run-summary surface — callers skip rather than fall back to a
+   * plain, never-updated `comment`, which would leave one stale copy per push.
+   */
+  upsertComment?(prNumber: number, marker: string, body: string, options?: { createIfAbsent?: boolean }): Promise<void>;
 }
 
 /** The git host to use this run, or nothing plus the reason PR operations are being skipped. */

package/sync/github-client.spec.ts

@@ -171,4 +171,164 @@ describe('GitHubClient', () => {
     const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl: fakeFetch });
     expect(await client.findPrByBranch('lane-x')).to.equal(undefined);
   });
+
+  describe('upsertComment', () => {
+    // named `upsertComment`, matching `GitHostProvider.upsertComment` exactly — see the method's
+    // own doc comment for why a differently-named method would be a silent-no-op trap.
+    function fakeFetchOver(existingComments: Array<{ id: number; body: string }>) {
+      const calls: Array<{ url: string; init: any }> = [];
+      const fetchImpl = (async (url: any, init: any) => {
+        calls.push({ url: String(url), init });
+        const method = init?.method ?? 'GET';
+        if (method === 'GET') {
+          return new Response(JSON.stringify(existingComments), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+          });
+        }
+        return new Response(JSON.stringify({}), { status: 200, headers: { 'content-type': 'application/json' } });
+      }) as typeof fetch;
+      return { calls, fetchImpl };
+    }
+
+    it('posts a new comment when no marked comment exists', async () => {
+      const { calls, fetchImpl } = fakeFetchOver([]);
+      const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl });
+      await client.upsertComment(7, '<!-- marker -->', '<!-- marker -->\nbody');
+      const posts = calls.filter((c) => c.init?.method === 'POST');
+      expect(posts).to.have.lengthOf(1);
+      expect(posts[0].url).to.equal('https://api.github.com/repos/acme/shop/issues/7/comments');
+    });
+
+    it('patches the marked comment in place, and never posts a second one', async () => {
+      const { calls, fetchImpl } = fakeFetchOver([
+        { id: 42, body: 'unrelated comment' },
+        { id: 99, body: '<!-- marker -->\nold report' },
+      ]);
+      const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl });
+      await client.upsertComment(7, '<!-- marker -->', '<!-- marker -->\nnew report');
+      const patches = calls.filter((c) => c.init?.method === 'PATCH');
+      expect(patches).to.have.lengthOf(1);
+      expect(patches[0].url).to.equal('https://api.github.com/repos/acme/shop/issues/comments/99');
+      expect(JSON.parse(patches[0].init.body)).to.deep.equal({ body: '<!-- marker -->\nnew report' });
+      expect(calls.some((c) => c.init?.method === 'POST')).to.equal(false);
+    });
+
+    it('skips silently when createIfAbsent is false and no marked comment exists', async () => {
+      const { calls, fetchImpl } = fakeFetchOver([]);
+      const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl });
+      await client.upsertComment(7, '<!-- marker -->', 'cleared', { createIfAbsent: false });
+      expect(calls.some((c) => c.init?.method === 'POST' || c.init?.method === 'PATCH')).to.equal(false);
+    });
+
+    it('lists at per_page=100 and follows Link-header pagination to find a comment past page 1', async () => {
+      // GitHub defaults to per_page=30; a naive single-page list would miss this comment and post a
+      // duplicate report on every push instead of updating it.
+      const calls: Array<{ url: string; init: any }> = [];
+      const fetchImpl = (async (url: any, init: any) => {
+        calls.push({ url: String(url), init });
+        const method = init?.method ?? 'GET';
+        if (method === 'GET' && !String(url).includes('page=2')) {
+          return new Response(JSON.stringify([{ id: 1, body: 'unrelated' }]), {
+            status: 200,
+            headers: {
+              'content-type': 'application/json',
+              link: '<https://api.github.com/repos/acme/shop/issues/7/comments?per_page=100&page=2>; rel="next"',
+            },
+          });
+        }
+        if (method === 'GET') {
+          return new Response(JSON.stringify([{ id: 99, body: '<!-- marker -->\nold report' }]), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+          });
+        }
+        return new Response(JSON.stringify({}), { status: 200, headers: { 'content-type': 'application/json' } });
+      }) as typeof fetch;
+      const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl });
+      await client.upsertComment(7, '<!-- marker -->', '<!-- marker -->\nnew report');
+
+      const gets = calls.filter((c) => (c.init?.method ?? 'GET') === 'GET');
+      expect(gets).to.have.lengthOf(2);
+      expect(gets[0].url).to.include('per_page=100');
+      expect(gets[1].url).to.equal('https://api.github.com/repos/acme/shop/issues/7/comments?per_page=100&page=2');
+      const patches = calls.filter((c) => c.init?.method === 'PATCH');
+      expect(patches).to.have.lengthOf(1);
+      expect(patches[0].url).to.equal('https://api.github.com/repos/acme/shop/issues/comments/99');
+      // the found-on-page-2 comment was updated, not duplicated
+      expect(calls.some((c) => c.init?.method === 'POST')).to.equal(false);
+    });
+
+    it('refuses to follow a Link header that leaves api.github.com — the token stays home', async () => {
+      // The next-page URL is response data, and requestRaw attaches the bearer token to whatever URL
+      // it is handed — an off-host "next" link must read as "last page", never as a request target.
+      const calls: Array<{ url: string; init: any }> = [];
+      const fetchImpl = (async (url: any, init: any) => {
+        calls.push({ url: String(url), init });
+        const method = init?.method ?? 'GET';
+        if (method === 'GET') {
+          return new Response(JSON.stringify([{ id: 1, body: 'unrelated' }]), {
+            status: 200,
+            headers: {
+              'content-type': 'application/json',
+              link: '<https://evil.test/repos/acme/shop/issues/7/comments?page=2>; rel="next"',
+            },
+          });
+        }
+        return new Response(JSON.stringify({}), { status: 200, headers: { 'content-type': 'application/json' } });
+      }) as typeof fetch;
+      const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl });
+      await client.upsertComment(7, '<!-- marker -->', '<!-- marker -->\nbody');
+
+      expect(calls.some((c) => c.url.includes('evil.test'))).to.equal(false);
+      const gets = calls.filter((c) => (c.init?.method ?? 'GET') === 'GET');
+      expect(gets, 'the off-host link is the last page, not a loop').to.have.lengthOf(1);
+    });
+
+    it('stops paginating as soon as the marked comment is seen', async () => {
+      const calls: Array<{ url: string; init: any }> = [];
+      const fetchImpl = (async (url: any, init: any) => {
+        calls.push({ url: String(url), init });
+        const method = init?.method ?? 'GET';
+        if (method === 'GET') {
+          return new Response(JSON.stringify([{ id: 99, body: '<!-- marker -->\nold report' }]), {
+            status: 200,
+            headers: {
+              'content-type': 'application/json',
+              link: '<https://api.github.com/repos/acme/shop/issues/7/comments?per_page=100&page=2>; rel="next"',
+            },
+          });
+        }
+        return new Response(JSON.stringify({}), { status: 200, headers: { 'content-type': 'application/json' } });
+      }) as typeof fetch;
+      const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl });
+      await client.upsertComment(7, '<!-- marker -->', '<!-- marker -->\nnew report');
+
+      const gets = calls.filter((c) => (c.init?.method ?? 'GET') === 'GET');
+      expect(gets, 'the match on page 1 makes page 2 pointless').to.have.lengthOf(1);
+      expect(calls.filter((c) => c.init?.method === 'PATCH')).to.have.lengthOf(1);
+    });
+
+    it('exhausting the page budget throws instead of posting a duplicate', async () => {
+      // "Ran out of budget" must not read as "absent": a POST here would add a duplicate report on
+      // every later push. The throw surfaces through the caller's existing warn-and-skip path.
+      const calls: Array<{ url: string; init: any }> = [];
+      const fetchImpl = (async (url: any, init: any) => {
+        calls.push({ url: String(url), init });
+        return new Response(JSON.stringify([{ id: 1, body: 'unrelated' }]), {
+          status: 200,
+          headers: {
+            'content-type': 'application/json',
+            link: '<https://api.github.com/repos/acme/shop/issues/7/comments?per_page=100&page=2>; rel="next"',
+          },
+        });
+      }) as typeof fetch;
+      const client = new GitHubClient({ token: 'tok', repo: 'acme/shop', fetchImpl });
+      let thrown: Error | undefined;
+      await client.upsertComment(7, '<!-- marker -->', '<!-- marker -->\nbody').catch((e) => (thrown = e));
+
+      expect(thrown, 'the budget exhaustion is an error, not an absence').to.be.an('error');
+      expect(calls.some((c) => c.init?.method === 'POST')).to.equal(false);
+    });
+  });
 });

package/sync/github-client.ts

@@ -32,6 +32,23 @@ export function isGitHubRemote(remoteUrl: string): boolean {
 
 const API = 'https://api.github.com';
 
+/**
+ * The `rel="next"` URL out of a GitHub `Link` response header, or undefined on the last page. The
+ * header is response data, and `requestRaw` attaches the bearer token to whatever URL it is handed —
+ * so a next link whose origin is not the API's reads as "last page", never as a request target.
+ */
+function nextPageUrl(linkHeader: string | null): string | undefined {
+  if (!linkHeader) return undefined;
+  const next = linkHeader.split(',').find((part) => part.includes('rel="next"'));
+  const url = next?.match(/<([^>]+)>/)?.[1];
+  if (!url) return undefined;
+  try {
+    return new URL(url).origin === API ? url : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /** Warning sink; a plain callback rather than a `Logger` so this module needs no logger aspect. */
 export type WarnFn = (message: string) => void;
 
@@ -85,8 +102,10 @@ export class GitHubClient implements GitHostProvider {
     return Boolean(this.token && this.repo);
   }
 
-  private async request(method: string, path: string, body?: unknown): Promise<any> {
-    const res = await this.fetchImpl(`${API}/repos/${this.repo}${path}`, {
+  /** `pathOrUrl` may be a path relative to this repo, or an absolute URL (a `Link` header's next page). */
+  private async requestRaw(method: string, pathOrUrl: string, body?: unknown): Promise<Response> {
+    const url = /^https?:\/\//i.test(pathOrUrl) ? pathOrUrl : `${API}/repos/${this.repo}${pathOrUrl}`;
+    const res = await this.fetchImpl(url, {
       method,
       headers: {
         authorization: `Bearer ${this.token}`,
@@ -98,8 +117,13 @@ export class GitHubClient implements GitHostProvider {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => '');
-      throw new Error(`GitHub API ${method} ${path} failed: ${res.status} ${text}`);
+      throw new Error(`GitHub API ${method} ${pathOrUrl} failed: ${res.status} ${text}`);
     }
+    return res;
+  }
+
+  private async request(method: string, path: string, body?: unknown): Promise<any> {
+    const res = await this.requestRaw(method, path, body);
     return res.status === 204 ? undefined : res.json();
   }
 
@@ -135,6 +159,60 @@ export class GitHubClient implements GitHostProvider {
   async addLabel(prNumber: number, label: string): Promise<void> {
     await this.request('POST', `/issues/${prNumber}/labels`, { labels: [label] });
   }
+
+  /**
+   * The marker-bearing comment on the PR, `'absent'` when every page was searched, or `'unknown'`
+   * when the defensive page cap cut the search short. GitHub defaults `per_page` to 30 and orders
+   * ascending, and the maintained comment is posted once, early in a PR's life — so it lives in the
+   * first pages and the search returns as soon as it is seen. `'unknown'` is distinct from `'absent'`
+   * because running out of budget must not read as "not there": the caller would post a duplicate
+   * report on every later push.
+   */
+  private async findMarkedComment(prNumber: number, marker: string): Promise<{ id: number } | 'absent' | 'unknown'> {
+    let next: string | undefined = `/issues/${prNumber}/comments?per_page=100`;
+    // Defensive cap: 20 pages (2,000 comments) is far past any real PR; without it a malformed or
+    // adversarial `Link` header could loop this call forever.
+    for (let page = 0; next && page < 20; page += 1) {
+      const res: Response = await this.requestRaw('GET', next);
+      const body = (await res.json()) as any[];
+      const match = body.find((c: any) => (c.body ?? '').includes(marker));
+      if (match) return { id: match.id };
+      next = nextPageUrl(res.headers.get('link'));
+    }
+    return next ? 'unknown' : 'absent';
+  }
+
+  /**
+   * Find the comment carrying `marker` (an HTML comment embedded in the body) and replace its body,
+   * or post `body` as a new comment when none exists and `options.createIfAbsent` is not false.
+   * GitHub's comment PATCH endpoint is `/issues/comments/{id}`, not `/issues/{pr}/comments/{id}` —
+   * a comment id is unique per repository, not scoped under the issue/PR that carries it.
+   *
+   * Named to match `GitHostProvider.upsertComment` exactly (not e.g. `upsertIssueComment`): a
+   * `GitHubClient` registered directly as a provider must satisfy the interface's optional method
+   * under its real name, or callers that feature-test via `gitHost.upsertComment` would silently
+   * treat a fully-capable client as unsupported.
+   */
+  async upsertComment(
+    prNumber: number,
+    marker: string,
+    body: string,
+    options: { createIfAbsent?: boolean } = {}
+  ): Promise<void> {
+    const existing = await this.findMarkedComment(prNumber, marker);
+    if (existing === 'unknown') {
+      // Surfaces through the caller's warn-and-skip path; posting blind would duplicate the report.
+      throw new Error(
+        `PR #${prNumber} has too many comments to establish whether the "${marker}" comment already exists`
+      );
+    }
+    if (existing !== 'absent') {
+      await this.request('PATCH', `/issues/comments/${existing.id}`, { body });
+      return;
+    }
+    if (options.createIfAbsent === false) return;
+    await this.comment(prNumber, body);
+  }
 }
 
 /**
@@ -191,6 +269,15 @@ export class GitHubHostProvider implements GitHostProvider {
     return this.requireClient().addLabel(prNumber, label);
   }
 
+  async upsertComment(
+    prNumber: number,
+    marker: string,
+    body: string,
+    options?: { createIfAbsent?: boolean }
+  ): Promise<void> {
+    return this.requireClient().upsertComment(prNumber, marker, body, options);
+  }
+
   private resolveClient(remoteUrl?: string): GitHubClient | undefined {
     if (!this.client) this.client = GitHubClient.fromEnv(remoteUrl ?? this.remoteHint, this.onWarning);
     return this.client;