canopycms 0.5.0 → 0.7.0

package/dist/worker/github-gateway-wire.js

@@ -107,6 +107,7 @@ export const answers = {
         merged_at: z.string().max(64).nullable(),
         state: z.enum(['open', 'closed']),
         node_id: z.string().max(256),
+        body: pullRequestText.body.nullable(),
     })
         .strict(),
     createOrUpdatePullRequest: pullRequestRef.extend({ created: z.boolean() }).strict(),

package/dist/worker/github-gateway.d.ts

@@ -62,7 +62,7 @@ export declare function describeMove(update: Extract<GitHubRefUpdate, {
     moved: true;
 }>): string;
 /** The fields of a pull request the worker reads. */
-export type GitHubPullRequest = Pick<RestEndpointMethodTypes['pulls']['get']['response']['data'], 'merged' | 'merged_at' | 'state' | 'node_id'>;
+export type GitHubPullRequest = Pick<RestEndpointMethodTypes['pulls']['get']['response']['data'], 'merged' | 'merged_at' | 'state' | 'node_id' | 'body'>;
 export type GitHubCreateOrUpdatePullRequest = Omit<CreateOrUpdatePullRequestParams, 'octokit' | 'owner' | 'repo' | 'signal'>;
 /**
  * Everything the worker does with GitHub, and the only place the credential and Octokit are used.

package/dist/worker/github-gateway.js

@@ -283,8 +283,8 @@ class LocalGitHubGateway {
     }
     /**
      * One fetch serves every caller: concurrent callers join it, and its result is answered again
-     * for {@link AUTH_SNAPSHOT_REUSE_MS}. A fetch is a request per user, so a worker asking in a loop
-     * would otherwise hold the provider's API at its rate limit. The fetch runs apart from every
+     * for {@link AUTH_SNAPSHOT_REUSE_MS}. A fetch pages the provider's whole user and membership lists,
+     * so a worker asking in a loop would otherwise hold the provider's API at its rate limit. The fetch runs apart from every
      * caller's signal, which ends only that caller's wait, so a retry after a timed-out wait joins it.
      */
     async authSnapshot(signal) {

package/dist/worker/github-transfer.js

@@ -246,16 +246,46 @@ async function causeOf(proc, err, reason) {
     const own = await proc.exited.then(() => null, (gitErr) => gitErr);
     return own !== null && getErrorMessage(own) !== reason ? own : err;
 }
+/**
+ * The most a fetch bundle's header may hold outside prerequisites' comments: a line per branch
+ * GitHub moved and one per boundary commit, so far more than a push's one head.
+ */
+const FETCH_BUNDLE_HEADER_MAX_BYTES = 16 * 1024 * 1024;
 /**
  * Unbundle the gateway's bundle `bundleId` into the repository at `gitDir`, under the pins. It
  * adds objects and moves no ref.
+ *
+ * Not `git bundle unbundle`, which first runs a connectivity walk from every ref in `gitDir`:
+ * from git 2.56 one corrupt object in any branch's history is fatal to that walk, and so to every
+ * fetch until an operator repairs `remote.git`, where a reconcile skips that branch alone. Each
+ * prerequisite is checked to be a commit by its object header instead, so one torn after its
+ * header is taken like torn history anywhere else, and left to its branch's reconcile. The pack
+ * goes to the `index-pack --fix-thin --stdin` that `bundle unbundle` runs after its walk. A delta
+ * whose base is missing still fails, in index-pack.
  */
 async function unbundle(ctx, gitDir, bundleId, signal) {
     const stream = await ctx.github().openBundle(bundleId);
     try {
-        await runGit(['bundle', 'unbundle', '--progress', '--end-of-options', '-'], {
+        const chunks = stream[Symbol.asyncIterator]();
+        const read = await readHeader(stream, chunks, ctx.taskTimeoutMs, signal);
+        const missing = await missingCommits(ctx, gitDir, read.header.prerequisites, signal);
+        if (missing.length > 0) {
+            throw new Error(`Refusing the bundle: its prerequisite ${missing[0]} is not a commit here`);
+        }
+        const { rest: first } = read;
+        const pack = Readable.from((async function* () {
+            if (first.length > 0)
+                yield first;
+            for (;;) {
+                const rest = await chunks.next();
+                if (rest.done)
+                    return;
+                yield rest.value;
+            }
+        })());
+        await runGit(['index-pack', '-v', '--fix-thin', '--stdin'], {
             ...sharedRepoProcessOptions(gitDir, 'bare'),
-            stdin: stream,
+            stdin: pack,
             inactivityTimeoutMs: ctx.taskTimeoutMs,
             signal,
         });
@@ -264,6 +294,46 @@ async function unbundle(ctx, gitDir, bundleId, signal) {
         stream.destroy();
     }
 }
+/**
+ * Read the header of the fetch bundle `stream`, bounded as git is (worker/git-process.ts): the
+ * stream is destroyed when `signal` aborts or nothing arrives for `inactivityTimeoutMs`, since no
+ * git runs yet to be stopped.
+ */
+async function readHeader(stream, chunks, inactivityTimeoutMs, signal) {
+    signal?.throwIfAborted();
+    let timer;
+    const onAbort = () => stream.destroy(new Error('Reading the bundle was aborted'));
+    signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+        const reader = new BundleHeaderReader('skip', FETCH_BUNDLE_HEADER_MAX_BYTES);
+        for (;;) {
+            clearTimeout(timer);
+            timer = setTimeout(() => stream.destroy(new Error(`The bundle sent nothing for ${inactivityTimeoutMs}ms`)), inactivityTimeoutMs);
+            const next = await chunks.next();
+            if (next.done)
+                throw new Error('The bundle ended before its header did');
+            const read = reader.push(next.value);
+            if (read !== null)
+                return read;
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', onAbort);
+    }
+}
+/** Of `ids`, those that are not a commit in the repository at `gitDir`. */
+async function missingCommits(ctx, gitDir, ids, signal) {
+    if (ids.length === 0)
+        return [];
+    const lines = (await runGit(['cat-file', '--batch-check=%(objectname) %(objecttype)', '--end-of-options'], {
+        ...sharedRepoProcessOptions(gitDir, 'bare'),
+        stdin: ids.map((id) => `${id}\n`).join(''),
+        inactivityTimeoutMs: ctx.taskTimeoutMs,
+        signal,
+    })).split('\n');
+    return ids.filter((id, i) => lines[i] !== `${id} commit`);
+}
 /**
  * Move the tracking namespace to exactly `refs`, every move stating the value it expects: all
  * deletions in one `update-ref` transaction, then every create and update in another. One

package/dist/worker/task-runner.js

@@ -12,6 +12,7 @@ import { RefusedPushError, assertPlainBranchName } from './github-mirror.js';
 import { pushToGitHub } from './github-transfer.js';
 import { clearHistoryRewrittenMarker, readPublishedSha } from './history-rewrite.js';
 import { writeWorkerStatus } from '../task-queue/worker-status.js';
+import { SYNC_PR_COMMENTS_ACTION, refreshCommentsBlock, renderPrCommentsBody } from '../pr-comments.js';
 import { workerLog, workerLogError, workerLogWarn } from './log.js';
 import { assertSharedRepoConfig } from './shared-repo-git.js';
 /**
@@ -331,16 +332,27 @@ export async function executeTask(ctx, task, signal) {
                 return { pushed: true };
             }
             await ctx.pushBranchToGitHub(branch, signal);
+            const mergeSectionIntoBody = payload.mergeSectionIntoBody === true;
+            const queuedBody = optionalString(payload, 'body', '');
+            const body = mergeSectionIntoBody
+                ? await refreshCommentsBlock({
+                    branchRoot: ctx.branchWorkspacePath(branch),
+                    branch,
+                    editorUrl: typeof payload.editorUrl === 'string' ? payload.editorUrl : undefined,
+                    section: queuedBody,
+                    warn: workerLogWarn,
+                })
+                : queuedBody;
             let result;
             try {
                 result = await ctx.github().createOrUpdatePullRequest({
                     head: branch,
                     base,
                     title: optionalString(payload, 'title', `Submit ${branch}`),
-                    body: optionalString(payload, 'body', ''),
+                    body,
                     // Content submits (api/github-sync.ts) set both.
                     markReadyIfDraft: payload.markReadyIfDraft === true,
-                    mergeSectionIntoBody: payload.mergeSectionIntoBody === true,
+                    mergeSectionIntoBody,
                 }, signal);
             }
             catch (err) {
@@ -414,6 +426,44 @@ export async function executeTask(ctx, task, signal) {
             workerLog(`Deleted GitHub branch ${branch}`);
             return { deleted: true };
         }
+        case 'sync-pr-comments': {
+            const branch = requireString(payload, 'branch');
+            const prNumber = requireNumber(payload, 'pullRequestNumber');
+            const editorUrl = typeof payload.editorUrl === 'string' ? payload.editorUrl : undefined;
+            const branchPath = ctx.branchWorkspacePath(branch);
+            // The branch under this name now: a deleted branch, or a newer one with another PR, has
+            // no say in this PR's summary. Corrupt metadata skips too, as the next submit rewrites it.
+            let live = null;
+            try {
+                live = await BranchMetadataFileManager.loadOnly(branchPath);
+            }
+            catch (err) {
+                if (!(err instanceof BranchMetadataCorruptError))
+                    throw err;
+            }
+            if (live?.branch.pullRequestNumber !== prNumber) {
+                return { updated: false, skipped: 'not-this-pr' };
+            }
+            const pr = await ctx.github().getPullRequest(prNumber, signal);
+            if (pr.state !== 'open')
+                return { updated: false, skipped: 'not-open' };
+            // A comments.json that does not parse stays so until a comment write rewrites it.
+            const body = await renderPrCommentsBody({
+                branchRoot: branchPath,
+                branch,
+                editorUrl,
+                body: pr.body,
+            }).catch((err) => {
+                if (err instanceof SyntaxError)
+                    throw new PermanentTaskError(getErrorMessage(err));
+                throw err;
+            });
+            if (body === undefined)
+                return { updated: false, skipped: 'unchanged' };
+            await ctx.github().updatePullRequest(prNumber, { body }, signal);
+            workerLog(`Updated the editor comments on PR #${prNumber} for ${branch}`);
+            return { updated: true };
+        }
         default:
             throw new PermanentTaskError(`Unknown task action: ${action}`);
     }
@@ -424,7 +474,7 @@ export async function executeTask(ctx, task, signal) {
  * name is leftover or a newer branch's that reused the name.
  */
 function metadataBranchOf(task) {
-    if (task.action === 'delete-remote-branch')
+    if (task.action === 'delete-remote-branch' || task.action === SYNC_PR_COMMENTS_ACTION)
         return null;
     return typeof task.payload.branch === 'string' ? task.payload.branch : null;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@codemirror/language, @lezer/highlight: workaround — @mdxeditor/editor uses cm6-theme-basic-light which peer-requires these but mdxeditor doesn't declare them as dependencies",
   "name": "canopycms",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "CanopyCMS core package: schema-driven content, branch-aware editing, and editor UI for Next.js.",
   "license": "MIT",
   "repository": {
@@ -161,7 +161,7 @@
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
-    "@playwright/test": "^1.57.0",
+    "@playwright/test": "^1.64.1",
     "@smithy/util-stream": "^3.0.0 || ^4.0.0",
     "@storybook/addon-essentials": "^8.1.11",
     "@storybook/react": "^8.1.11",

package/dist/editor/fields/markdown-export-options.d.ts

@@ -1,2 +0,0 @@
-import type { ToMarkdownOptions } from '@mdxeditor/editor';
-export declare const MARKDOWN_EXPORT_OPTIONS: ToMarkdownOptions;

package/dist/editor/fields/markdown-export-options.js

@@ -1,8 +0,0 @@
-// Prettier's markers. The prop replaces MDXEditor's defaults, so `listItemIndent` is restated.
-export const MARKDOWN_EXPORT_OPTIONS = {
-    listItemIndent: 'one',
-    bullet: '-',
-    emphasis: '_',
-    strong: '*',
-    rule: '-',
-};