canopycms 0.12.0 → 0.13.0

package/dist/worker/git-sync.d.ts

@@ -16,7 +16,8 @@ import type { WorkerContext } from './worker-context.js';
  * says the serving editor lacks a schema the incoming content names), push this
  * deployment's own settings
  * branch, fast-forward the base branch's workspace, ask the gateway for its branch policy,
- * rebase every branch that is behind it (rebase.ts), then sweep old tasks, expired trashed
+ * rebase every branch that is behind it (rebase.ts), set each pull request's conflicts status
+ * (conflicts-status.ts), then sweep old tasks, expired trashed
  * branch directories and, where retention is on, expired archived branches.
  *
  * One ordering is load-bearing and nothing enforces it: `runRebaseCycle` MUST
@@ -32,7 +33,7 @@ import type { WorkerContext } from './worker-context.js';
  * The whole cycle is wrapped so both outcomes record a worker-status.json
  * snapshot, since an operator's only view of this loop is the admin panel.
  */
-export type GitSyncContext = Pick<WorkerContext, 'baseBranch' | 'sanitizedBaseBranch' | 'contentBranchesPath' | 'remoteGitPath' | 'schemaHoldMaxMs' | 'archivedBranchRetentionDays' | 'taskDir' | 'taskTimeoutMs' | 'log' | 'github' | 'ensureSettingsBranch' | 'ensureStatusReport' | 'warnedDivergences' | 'isRunning' | 'isDraining' | 'shutdownSignal'> & RebaseContext;
+export type GitSyncContext = Pick<WorkerContext, 'baseBranch' | 'sanitizedBaseBranch' | 'contentBranchesPath' | 'remoteGitPath' | 'schemaHoldMaxMs' | 'archivedBranchRetentionDays' | 'taskDir' | 'taskTimeoutMs' | 'log' | 'github' | 'ensureSettingsBranch' | 'ensureStatusReport' | 'warnedDivergences' | 'conflictsStatusesSet' | 'isRunning' | 'takeBranchSyncRequests' | 'isDraining' | 'shutdownSignal'> & RebaseContext;
 /**
  * Push THIS deployment's own settings branch (`ensureSettingsBranch()`) from
  * remote.git to GitHub. Non-fatal. Skipped when `trackedTips`, GitHub's tips

package/dist/worker/git-sync.js

@@ -14,6 +14,7 @@ import { escapeForLog } from '../utils/escape-text.js';
 import { CANOPY_META_DIR, isCanopyInternalPath, isNonFastForwardRejection } from '../utils/git.js';
 import { MAX_REPORTED_PATHS, TRACKED_CANOPY_STATE_FIX, isUntracked, listTrackedCanopyState, restoreRetiredSchemaCache, splitByUpstreamTracking, untrackInIndex, } from './canopy-state.js';
 import { sweepArchivedBranches } from './archived-sweep.js';
+import { setConflictsStatuses } from './conflicts-status.js';
 import { hasPendingHistoryRewrite, recordSeenOnGitHub } from './history-rewrite.js';
 import { runRebaseCycle } from './rebase.js';
 import { describeMove } from './github-gateway.js';
@@ -418,6 +419,9 @@ function warnOnce(warned, lines) {
 export async function syncGit(ctx) {
     if (!ctx.isRunning())
         return;
+    // Taken first, so a cycle that fails before its fetch can't leave the loop waking early for good.
+    // A request made later in the cycle waits for the next one, whose fetch begins after it.
+    const requested = ctx.takeBranchSyncRequests();
     // The CDK worker-down alarm counts this line (WORKER_SYNC_LOG_PHRASE in
     // canopycms-cdk worker-lifecycle.ts); changing its text breaks the alarm.
     workerLog('Syncing git...');
@@ -468,8 +472,9 @@ export async function syncGit(ctx) {
         // deadline: the wait for the gateway's GitHub fetch, which runs on detached, then the gateway's
         // bundle, the unbundle and the ref update; a killed ref update leaves each ref as it was or
         // fully moved.
-        const fetchedAt = Date.now();
-        const { refs: githubTips, needsOperator } = await fetchGitHubIntoRemoteGit(ctx, ctx.shutdownSignal());
+        // A woken cycle takes no GitHub fetch the gateway began earlier: answers to a request for the
+        // latest changes are timed by this fetch's start (worker/rebase.ts, answerBaseUpdate).
+        const { refs: githubTips, fetchedAt, needsOperator, } = await fetchGitHubIntoRemoteGit(ctx, ctx.shutdownSignal(), requested.requested);
         workerLog('Fetched from GitHub');
         if (needsOperator !== null)
             workerLogError(needsOperator);
@@ -512,12 +517,12 @@ export async function syncGit(ctx) {
             report.gatewayProtectedBranches = branchPolicy.configured.filter((n) => !n.includes('*'));
             await writeWorkerStatus(ctx.taskDir, report).catch((writeErr) => workerLogError('Failed to write worker status:', getErrorMessage(writeErr)));
         }
-        const rebaseSummary = await runRebaseCycle(ctx, branchPolicy, {
-            tips: githubTips,
-            fetchedAt,
-        });
+        const rebaseSummary = await runRebaseCycle(ctx, branchPolicy, { tips: githubTips, fetchedAt }, requested.branches);
         if (stoppedForDrain(ctx, 'the cleanup sweeps'))
             return;
+        // After the rebase cycle, whose merges can change a branch's conflicts. Heads the cycle's own
+        // pushes move are set by the cycle each push wakes.
+        const conflictsStatusFailure = await setConflictsStatuses(ctx, githubTips);
         await cleanupOldTasks(ctx.taskDir, undefined, ctx.log);
         // For System health: the branches the gateway would refuse to publish, read after the rebase
         // cycle, which archives merged branches and restores renamed ones. Without a policy, a fatal
@@ -550,6 +555,11 @@ export async function syncGit(ctx) {
         const report = ctx.ensureStatusReport();
         report.lastGitSyncAt = new Date().toISOString();
         delete report.lastGitSyncError;
+        // null: the stage could not say, so the last report stands.
+        if (conflictsStatusFailure)
+            report.conflictsStatusFailure = conflictsStatusFailure;
+        else if (conflictsStatusFailure === undefined)
+            delete report.conflictsStatusFailure;
         // Recorded once the cycle has done everything it can, so System health shows it.
         if (needsOperator !== null) {
             report.lastGitSyncError = { message: needsOperator, at: report.lastGitSyncAt };

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

@@ -44,9 +44,13 @@ export type GitHubCommitsOutcome =
  | {
     kind: 'unpushed';
 }
-/** A merge landed. A rebase now would replace a merge GitHub has not received. */
+/**
+ * A merge landed. A rebase now would replace a merge GitHub has not received. `keptEntries`
+ * counts the entries with a conflict it left for a person.
+ */
  | {
     kind: 'merged';
+    keptEntries: number;
 }
 /** Left as it is until a person acts. `reason` says what to do. */
  | {
@@ -76,28 +80,56 @@ export declare const SEEN_COMMIT_GONE_PUSH_REFUSAL = "A commit this branch had o
  * be combined. The failed sync it left goes too, unless {@link awaitsSubmitRetry}.
  */
 export declare function rewriteCleared(branch: BranchMetadata): Partial<BranchMetadata>;
+/** A branch this deployment put on GitHub. Any other GitHub branch of that name is not its own. */
+export declare function isPublished({ branch }: BranchMetadataFile): boolean;
+/**
+ * Fast-forward the clone to the merge this worker was landing, when `remote.git` holds it on top of
+ * the clone, as a crash or a lost lock between publishing it and moving the clone leaves it,
+ * whether or not the branch is on GitHub. Resolves why it stopped, or null when there was nothing
+ * to catch up with or it caught up.
+ */
+export declare function catchUpWithPublished(ctx: GitHubCommitsContext, args: GitHubCommitsArgs): Promise<GitHubCommitsOutcome | null>;
 /** Bring GitHub's commits into the clone. Throws what git throws; the caller records it. */
 export declare function bringInGitHubCommits(ctx: GitHubCommitsContext, args: GitHubCommitsArgs): Promise<GitHubCommitsOutcome>;
 /**
- * `other` merged into the branch: built, published to `remote.git`, queued for GitHub, and the
- * clone moved to it, in that order, so each step leaves what the next cycle picks up and only the
- * last touches the working tree. `fromGitHub` says `other` is GitHub's tip rather than the base.
- * `stopOnConflict` leaves a branch in review as it is: nobody is at the editor to see what a kept
- * version replaced, and GitHub's own conflict notice stands on the pull request.
+ * `other` merged into the branch: built, recorded, published to `remote.git` and queued for GitHub
+ * unless it holds unsubmitted work (publish-decision.ts), and the clone moved to it, in that order,
+ * so each step leaves what the next cycle picks up and only the last touches the working tree. `fromGitHub` says `other` is GitHub's tip rather than the
+ * base. `inReview` takes only a merge with nothing for a person to choose; any other leaves the
+ * branch as it is and records nothing, and GitHub's own conflict notice stands on the pull request. A lock lost before the clone moves leaves it where it was: `wait`.
  */
 export declare function mergeIntoBranch(ctx: GitHubCommitsContext, args: GitHubCommitsArgs, merge: {
     head: string;
     other: string;
     message: string;
     fromGitHub: boolean;
-    stopOnConflict?: boolean;
+    inReview?: boolean;
 }): Promise<GitHubCommitsOutcome>;
 /**
- * Send an approved branch back to review and clear the verdict from the PR body. Before the clone
- * moves, and a failed save throws, so a crash or a failure leaves the commits for the next cycle
- * to judge again rather than an approval standing over them.
+ * Whether `commit` contains `ancestor`. A commit this clone does not hold counts as no. Any other
+ * failure throws, since it says nothing about either commit, and the caller's catch retries next
+ * cycle: read as no, it would report a rewrite that never happened.
+ */
+export declare function contains(git: SimpleGit, commit: string, ancestor: string): Promise<boolean>;
+/**
+ * Send an approved branch back to review and clear the verdict from the PR body. Called before the
+ * clone moves, where a failed save throws, so a crash or a failure leaves the commits for the next
+ * cycle to judge again rather than an approval standing over them.
  */
 export declare function returnToReview(ctx: GitHubCommitsContext, { branchPath, branchDir, branchRef, metaFile }: GitHubCommitsArgs): Promise<void>;
+/**
+ * Bring merge-conflicts.json in line with the branch's history: a record changed by a merge the
+ * branch never got gives back the one it replaced (`withoutMergesGone`), and `branch.json`
+ * `conflictFiles` follows the record when the two differ. A merge counts as held while the clone or
+ * `remote.git` holds it, since a clone behind its published merge catches up with it; comment
+ * threads take a merge's item keys only once the clone holds it. While either can't be read in the
+ * clone, nothing is judged. A record that does not parse is moved aside, so the branch's merges
+ * carry on with a new one. Each cycle, before the branch takes anything in. A clone with no record
+ * has no conflict open, so `conflictFiles` written before the record existed clears. Never throws.
+ */
+export declare function reconcileMergeConflicts(ctx: GitHubCommitsContext, { git, branchPath, branchDir, branchRef, }: Pick<GitHubCommitsArgs, 'git' | 'branchPath' | 'branchDir'> & {
+    branchRef: string | null;
+}): Promise<void>;
 /**
  * Re-render the PR body's review block alone: the worker has no `config.editorUrl`, so a full
  * sync from here would strip the comment summary's links. Best-effort: a failure leaves the block