canopycms 0.0.61-int.75 → 0.0.61

package/dist/worker/cms-worker.d.ts

@@ -1,3 +1,4 @@
+export { workerLog, workerLogWarn, workerLogError, installWorkerLogger } from './log';
 /**
  * Auth cache refresh function type.
  * Adopters provide their auth-plugin-specific implementation.
@@ -27,6 +28,25 @@ export interface CmsWorkerConfig {
     authCacheRefreshInterval?: number;
     /** Base branch name (default: 'main') */
     baseBranch?: string;
+    /**
+     * Deployment name, used to compute THIS worker's own settings branch
+     * (`canopycms-settings-{deploymentName}`, default: 'prod' — matches
+     * ProdStrategy's mode default in operating-mode/client-unsafe-strategy.ts,
+     * the only mode the worker runs in). Two deployments can share one GitHub
+     * repo with distinct settings branches; this tells the worker which one it
+     * owns, so it never pushes another deployment's settings branch (see
+     * `pushSettingsBranches`).
+     */
+    deploymentName?: string;
+    /**
+     * Explicit settings branch name, taking precedence over `deploymentName`.
+     * Mirrors the strategy's own precedence (`config.settingsBranch` short-circuits
+     * `getSettingsBranchName` before `deploymentName` is consulted, see
+     * operating-mode/client-unsafe-strategy.ts): an adopter who overrides
+     * `settingsBranch` in canopycms.config.ts must set this too, or the worker
+     * would own a branch name the Lambda never writes to.
+     */
+    settingsBranch?: string;
     /** Max tasks to process per cycle (default: 10) */
     maxTasksPerCycle?: number;
     /** Per-task timeout in ms (default: 60000) */
@@ -93,6 +113,7 @@ export declare class CmsWorker {
     private contentBranchesPath;
     private baseBranch;
     private sanitizedBaseBranch;
+    private settingsBranchResolved?;
     private activeTimeouts;
     private running;
     private activeOperations;
@@ -115,6 +136,35 @@ export declare class CmsWorker {
      * syncGit()/processTaskQueue() directly without calling start() first.
      */
     private ensureStatusReport;
+    /**
+     * Resolve this deployment's settings branch, throwing if the infra-stamped
+     * deployment name is not a valid git ref component.
+     *
+     * Routed through the shared resolver, not a local `?? 'prod'`: it is the
+     * single definition of the env > config > mode-default precedence the Lambda
+     * already follows, and the only place the resolved value is validated.
+     * Without it the worker could silently own a different settings branch than
+     * the Lambda writing to the same workspace -- and pushSettingsBranches would
+     * then report the real branch as foreign and never push it.
+     *
+     * DEFERRED out of the constructor deliberately, and this is the whole point
+     * of the method existing. Resolving there made the throw land during `new
+     * CmsWorker(...)` (canopycms-cdk/worker/index.ts constructs before it calls
+     * start()), which is BEFORE the only code that writes `lastFatalError` --
+     * start()'s catch. The result was billed as "a loud startup exit" but was
+     * nothing of the kind: with systemd `Type=simple` + `Restart=always` and no
+     * cfn-signal, an invalid deployment name produced an invisible ~5s
+     * crash-loop that `cdk deploy` reported as success while the admin panel
+     * showed the worker as 'absent' with no fatal error to explain it. Resolving
+     * inside start()'s try block instead means the same throw is recorded to
+     * worker-status.json and surfaces in the admin panel.
+     *
+     * Lazy rather than start()-only so the value is still available to unit tests
+     * that drive pushSettingsBranches() directly without calling start() -- the
+     * same reason ensureStatusReport() above is shaped this way. Idempotent: the
+     * resolver is pure, so a later call returns the identical string.
+     */
+    private ensureSettingsBranch;
     start(): Promise<void>;
     stop(): Promise<void>;
     /**
@@ -183,6 +233,17 @@ export declare class CmsWorker {
      * guard existed.
      */
     private ensureRemoteGit;
+    /**
+     * Staleness threshold for recoverOrphanedTasks, derived from the
+     * configured task timeout rather than fixed: the safety argument for
+     * running recovery on every poll cycle is "no legitimately in-flight task
+     * can be this old, because executeTaskWithTimeout bounds every attempt by
+     * taskTimeoutMs" -- which is only true if this threshold scales with
+     * taskTimeoutMs. 2x leaves the same comfortable margin the defaults have
+     * (60s timeout vs 5min threshold); the 5-minute floor preserves the
+     * long-standing default for a replacement instance's boot window.
+     */
+    private orphanRecoveryMaxAgeMs;
     /**
      * Process queued tasks from Lambda.
      * Polls .tasks/pending/ directory and executes each task.
@@ -208,16 +269,184 @@ export declare class CmsWorker {
     private updateBranchMetadata;
     /**
      * Update branch metadata after permanent task failure.
-     * Sets syncStatus to 'sync-failed' with error details.
+     * Sets syncStatus to 'sync-failed' and records `error` (already redacted
+     * by the caller, processTaskQueue -- see [HIGH-1] there) as
+     * syncFailureReason, so the editor can show WHY, not just that it failed.
      */
     private updateBranchMetadataOnFailure;
     private buildGitHubUrl;
+    /**
+     * The workspace directory for a branch named by its GIT REF name -- the
+     * form task payloads carry (`context.branch.name`), not the directory form.
+     *
+     * These differ for any name outside `[A-Za-z0-9._-]`, `/` being the obvious
+     * one: workspaces are provisioned under `sanitizeBranchName(...)` (see
+     * paths/branch.ts's `resolveBranchPaths`), so `feature/x` lives in
+     * `feature-x`. Joining the raw name instead silently addresses a directory
+     * that does not exist -- which for the metadata writers below meant the
+     * update was quietly dropped, and for the leased push meant the
+     * history-rewrite marker read as absent and the push went out unleased,
+     * wedging exactly the branch this workstream exists to unwedge.
+     *
+     * `name` inside the metadata itself stays the raw ref name; only the path
+     * is sanitized.
+     */
+    private branchWorkspacePath;
+    /**
+     * What `remote.git` currently holds for `branchRef`, or null when this
+     * branch was never published there (never submitted) or the ref is
+     * unreadable.
+     *
+     * Uses the same explicit `--git-dir` shape as verifyBaseBranchExists()
+     * above: reading a bare repo that way does not depend on
+     * `safe.bareRepository` being permissive, which is why prod code takes
+     * this route rather than the config override the test-only `openBareRepo`
+     * helper uses.
+     */
+    private readPublishedSha;
+    /**
+     * Record that this worker rewrote `expectedSha` out of a branch's already
+     * published history (see BranchMetadata.historyRewrittenFrom).
+     *
+     * Set-once: if a marker is already present it is LEFT ALONE. Across two
+     * rebases before any GitHub push lands, GitHub still holds the commit the
+     * FIRST rebase replaced, so advancing the marker would aim the lease at a
+     * commit GitHub never had and permanently wedge the branch.
+     *
+     * Re-reads metadata rather than trusting the caller's loop-top snapshot:
+     * the task loop runs concurrently with syncGit() (see scheduleLoop) and may
+     * have cleared the marker while this branch was rebasing.
+     */
+    private markHistoryRewritten;
+    /**
+     * Clear the marker once GitHub is confirmed to hold the rewritten history.
+     *
+     * Best-effort only in the sense that a failure here destroys nothing: the
+     * lease still refuses anything unexpected, and the plain-push fallback only
+     * ever fast-forwards. It is NOT harmless. A marker that outlives its
+     * episode can wedge the NEXT one -- if the base advances before the stale
+     * marker is revisited, the queued push leases a commit GitHub has already
+     * moved off, falls back to a plain push of a rebased (non-ancestor)
+     * history, and fails permanently with a "something else moved it on
+     * GitHub" diagnosis that is false: we did.
+     *
+     * Tracked, with the concurrent-clear race that can drop a marker
+     * mid-arming, in
+     * .claude/future-tasks/worker-history-rewrite-marker-races.md.
+     */
+    private clearHistoryRewrittenMarker;
+    /**
+     * Publish a branch clone's rebased history into `remote.git`, replacing
+     * EXACTLY `expectedSha` and nothing else.
+     *
+     * The lease is the entire safety argument. `--force-with-lease=<ref>:<sha>`
+     * refuses unless `remote.git` still stands at `<sha>`, so this can only
+     * ever undo the commit our own rebase rewrote away. Callers must never pass
+     * "whatever remote.git currently holds" -- see the arming guard in
+     * rebaseActiveBranches() for the interleaving where that would silently
+     * delete a reviewer's direct push.
+     *
+     * Returns whether the push landed. A refused lease means a concurrent
+     * Lambda push moved the ref; that is logged and retried by the self-heal
+     * pass on a later cycle, never thrown.
+     */
+    private forcePublishToLocalRemote;
+    /**
+     * Queue the GitHub hop for a branch whose rewritten history now sits in
+     * `remote.git`, so an open PR's head follows the rebase within a cycle
+     * instead of waiting for the editor's next submit.
+     *
+     * Deliberately NOT skipped when a marker is already set: inferring "a task
+     * must already be queued" from the marker starves this hop whenever a task
+     * was lost, failed permanently, or was never written. Duplicate push tasks
+     * are bounded by base-branch advances and are idempotent (a repeat push is
+     * a no-op once GitHub holds the tip).
+     */
+    private enqueueGitHubPush;
+    /**
+     * Complete a rewrite this worker started but did not finish: get the
+     * rebased history into `remote.git` and queued for GitHub.
+     *
+     * Runs from the rebase loop for any branch carrying a marker, whether or
+     * not it is behind base this cycle, so an interrupted publish converges
+     * without waiting for the next base-branch advance.
+     *
+     * Always leases on the MARKER, never on remote.git's current tip -- the
+     * marker is the one commit we know our own rebase replaced.
+     */
+    private reconcilePendingRewrite;
     private pushBranchToGitHub;
     /**
-     * Push any canopycms-settings-* branches from remote.git to GitHub.
-     * Non-fatal: a no-op push for up-to-date branches just succeeds quietly.
+     * Push THIS deployment's own settings branch (`ensureSettingsBranch()`) from
+     * remote.git to GitHub. Non-fatal: a no-op push for an up-to-date branch
+     * just succeeds quietly.
+     *
+     * Deliberately narrowed to one branch — this used to push EVERY local
+     * branch matching `canopycms-settings-*`. With the tracking-namespace fetch
+     * fix (GITHUB_TRACKING_REF_PREFIX), `reconcileTrackedBranches` creates local
+     * heads for branches that exist on GitHub, so ANOTHER deployment's settings
+     * branch (sharing this same GitHub repo) can legitimately show up as a
+     * local head here too. Pushing it would be this deployment shipping
+     * settings state it doesn't own.
      */
     private pushSettingsBranches;
+    /**
+     * Bring `refs/heads/*` in `remote.git` toward what was just fetched into
+     * `GITHUB_TRACKING_REF_PREFIX` -- WITHOUT ever force-rewinding or deleting
+     * a local head. This is the non-destructive replacement for what the old
+     * `+refs/heads/*:refs/heads/*` fetch refspec used to do implicitly (and
+     * destructively) as part of the fetch itself; see
+     * `GITHUB_TRACKING_REF_PREFIX`'s doc comment for the two failure modes
+     * that refspec caused.
+     *
+     * Per tracked branch:
+     * - no local `refs/heads/<name>` yet -> create it at the tracked commit
+     *   (a branch created on GitHub, or by another deployment sharing this
+     *   GitHub repo, becomes visible locally).
+     * - local is a strict ancestor of tracked (behind) -> fast-forward it.
+     * - local === tracked -> nothing to do.
+     * - tracked is a strict ancestor of local (ahead) -> LEAVE IT ALONE. This
+     *   is unpushed editor/settings work; the queued push task (or
+     *   pushSettingsBranches) ships it. This is exactly the branch state the
+     *   old refspec used to destroy.
+     * - neither is an ancestor of the other (diverged) -> LEAVE IT ALONE and
+     *   count/log it. A real collision (e.g. another deployment moved the
+     *   same branch name on GitHub); the next push attempt will be rejected
+     *   non-fast-forward, which is the correct, visible outcome -- this
+     *   method must never silently pick a winner. The one expected, benign
+     *   form of this -- our own rebase loop having published a rewrite into
+     *   remote.git with the GitHub push still queued -- is split out into the
+     *   `rewritten` bucket so the collision warning stays meaningful.
+     *
+     * Never deletes a local head: a branch removed on GitHub simply stops
+     * being tracked here; the local ref persists until removed through its
+     * own explicit path (the sync loop must not be one of them).
+     *
+     * `remote.git` is bare, so there is no worktree to invalidate by moving
+     * these refs -- unlike a non-bare repo, updating the ref that happens to
+     * be "checked out" is a non-issue here.
+     *
+     * Concurrency: `remote.git` is bare and on EFS, and the Lambda pushes into
+     * it concurrently (`GitManager.push()`'s `target:target` refspec) while
+     * this runs. Every `update-ref` below passes the expected old value (the
+     * all-zeros OID for "must not exist yet" on creation, the previously-read
+     * SHA for the fast-forward case) so a concurrent Lambda write landing in
+     * the gap between the read and the write loses the ref update instead of
+     * being silently clobbered -- the branch is simply revisited next cycle.
+     */
+    private reconcileTrackedBranches;
+    /**
+     * Whether this branch carries a pending history rewrite -- the rebase loop
+     * rewrote already-published history and the GitHub push has not landed yet
+     * (see BranchMetadata.historyRewrittenFrom).
+     *
+     * `branchName` is a git ref name; branch workspaces are directories named
+     * with the sanitized form, hence the conversion. Best-effort: a settings
+     * branch (no workspace at all), a missing directory or an unreadable
+     * branch.json all mean "no known rewrite", which is the conservative
+     * answer -- it keeps the branch in the louder `diverged` bucket.
+     */
+    private hasPendingHistoryRewrite;
     syncGit(): Promise<void>;
     /**
      * [C1] Remove `.trash-*` branch directories (created by the admin purge

package/dist/worker/cms-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cms-worker.d.ts","sourceRoot":"","sources":["../../src/worker/cms-worker.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cms-worker.d.ts","sourceRoot":"","sources":["../../src/worker/cms-worker.ts"],"names":[],"mappings":"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"}