@teambit/ci 1.0.484 → 1.0.486

package/dist/sync/main-sync-executor.js

@@ -0,0 +1,305 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MainSyncExecutor = void 0;
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _git() {
+  const data = require("../git");
+  _git = function () {
+    return data;
+  };
+  return data;
+}
+function _syncState() {
+  const data = require("./sync-state");
+  _syncState = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceLane() {
+  const data = require("./workspace-lane");
+  _workspaceLane = function () {
+    return data;
+  };
+  return data;
+}
+function _laneSyncExecutor() {
+  const data = require("./lane-sync-executor");
+  _laneSyncExecutor = function () {
+    return data;
+  };
+  return data;
+}
+function _gitOps() {
+  const data = require("./git-ops");
+  _gitOps = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Reconcile the main scope with the repository's default branch. Stateless: `bit checkout head`
+ * writes the latest exported versions, so an empty `git status` IS convergence and any diff IS the
+ * drift. Under 'pr' the convergence is proposed via `mainSyncBranch`; under 'direct-push' it lands on
+ * the default branch with a plain push. Nothing is ever force-pushed in either mode.
+ */
+/** the "nothing to do" line, shared by both modes */
+const CONVERGED_SUMMARY = 'main -> converged (checkout head produced no changes)';
+class MainSyncExecutor {
+  constructor(deps) {
+    this.deps = deps;
+  }
+
+  /**
+   * Returns a summary line (HALT-prefixed on failure) and, like `syncLane`, does not throw — a
+   * main-sync failure must not erase the lane results collected before it.
+   */
+  async syncMain(opts = {}) {
+    const {
+      cfg,
+      defaultBranch,
+      defaultScope,
+      logger
+    } = this.deps;
+    const directPush = cfg.mainSync === 'direct-push';
+    // In direct-push mode the sync branch (and its PR) is not consulted, moved or deleted.
+    const branch = directPush ? defaultBranch : cfg.mainSyncBranch;
+    if (cfg.autoMergeMainSyncPr && !directPush) {
+      // Enabling auto-merge is host-specific and not part of the GitHostProvider contract.
+      logger.consoleWarning(`sync.autoMergeMainSyncPr is enabled in the config, but enabling auto-merge is not implemented yet — ` + `the sync PR is opened without it. Use a repository auto-merge rule instead.`);
+    }
+    try {
+      await (0, _gitOps().fetchRemoteHeads)();
+      // Direct-push always starts from `origin/<defaultBranch>` — the very tip the plain push must
+      // fast-forward. In 'pr' mode an existing sync branch is reused so its PR history survives.
+      const syncBranchExists = directPush ? false : await (0, _gitOps().branchExistsOnRemote)(branch);
+      const startPoint = syncBranchExists ? `origin/${branch}` : `origin/${defaultBranch}`;
+      logger.console(_chalk().default.blue(directPush ? `main -> checking the main scope against ${defaultBranch} (direct-push)` : `main -> checking the main scope against ${defaultBranch} (sync branch ${branch})`));
+      await this.resetToStartPoint(branch, startPoint);
+      if (syncBranchExists) {
+        // Catch up with the default branch: the PR must stay mergeable, and `checkout head` on a stale
+        // tree would re-commit pre-merge content over the default branch's changes. A merge — never a
+        // rebase, never a force-push — is the only non-destructive way to move a branch with an open PR.
+        const catchUpErr = await this.catchUpWithDefaultBranch(branch);
+        if (catchUpErr) return `${_laneSyncExecutor().HALT_SUMMARY_PREFIX} main -> ${catchUpErr}`;
+      }
+
+      // `checkout head` resolves versions against the CURRENT lane; a lane pointer on this branch
+      // would make the "drift" the lane's content. Refuse rather than open a wildly wrong PR.
+      // `.bitmap`-derived read: the scope-object read answers "main" on a fresh runner and the guard
+      // would silently stop refusing exactly where it ships (see `workspace-lane.ts`).
+      const currentLane = (0, _workspaceLane().currentLaneIdStr)(this.deps.lanes);
+      if (currentLane) {
+        return `${_laneSyncExecutor().HALT_SUMMARY_PREFIX} main -> the .bitmap on ${startPoint} points at lane ` + `"${currentLane}" rather than main, so the main-scope drift cannot be computed`;
+      }
+
+      // `checkoutByCLIValues` rather than `checkout`: it imports current objects first (so `head`
+      // resolves to the remote scope's versions) and persists `.bitmap` on destroy.
+      // `includeNewFromScope`: a component exported to the scope's main but never in this repo's
+      // `.bitmap` would otherwise be invisible to every sync run forever.
+      // `mergeStrategy: 'theirs'` is required: unexported source drift makes components "modified",
+      // and with no strategy the checkout throws. 'theirs' materializes the exported truth — any
+      // reversion of unexported drift is visible in the PR diff. 'ours' is forbidden: it would advance
+      // `.bitmap` while keeping the old files, a commit asserting a state the tree does not have.
+      const results = await this.deps.checkout.checkoutByCLIValues('', {
+        head: true,
+        skipNpmInstall: true,
+        includeNewFromScope: true,
+        mergeStrategy: 'theirs'
+      });
+      const newFromScope = results.newFromScope ?? [];
+      if (newFromScope.length) {
+        logger.console(_chalk().default.blue(`Added ${newFromScope.length} component(s) that exist on ${defaultScope}'s main but not in this ` + `workspace: ${newFromScope.join(', ')}`));
+      }
+      const drift = await this.driftFiles();
+      // Direct-push stays bare: asking the host about `mainSyncBranch`'s PR would be the one
+      // interaction with it this mode promises not to make.
+      if (!drift.length) return directPush ? CONVERGED_SUMMARY : await this.convergedSummary(branch);
+      logger.console((0, _cli().formatWarningSummary)(`main -> drift in ${drift.length} file(s): ${drift.slice(0, 20).join(', ')}`));
+      if (opts.dryRun) {
+        // The working tree WAS written (a diff-based check has no other way); `finally` restores it. Safe
+        // only because a dry run over a dirty tree is refused before anything runs — the restore rewinds
+        // to HEAD, so an uncommitted change here would be gone (`assertCleanForDryRun`).
+        logger.console((0, _cli().formatWarningSummary)(directPush ? `Dry-run: main -> would push the drift directly onto ${branch}` : `Dry-run: main -> would push ${branch} and open a sync PR`));
+        return directPush ? `main -> drift detected in ${drift.length} file(s) — would push ${branch} directly` : `main -> drift detected in ${drift.length} file(s) — would open sync PR`;
+      }
+      await (0, _gitOps().addAllExceptScopeAndModules)();
+      await (0, _gitOps().commitWithIdentity)(mainSyncCommitMessage(drift.length));
+      // Never force: a rejected push means a concurrent run pushed in between, and in direct-push mode
+      // that rejection is the whole safety story for the default branch. Unambiguous refspec — see
+      // `lane-sync-executor.commitAllAndPush`.
+      await _git().git.push(['origin', `HEAD:refs/heads/${branch}`]);
+      logger.console(_chalk().default.green(`Pushed ${branch}`));
+      if (directPush) {
+        const shortSha = (await _git().git.revparse(['--short', 'HEAD'])).trim();
+        return `main -> direct-push (pushed ${branch} @ ${shortSha})`;
+      }
+      const prUrl = await this.ensureSyncPr({
+        branch,
+        driftCount: drift.length,
+        newFromScope
+      });
+      return `main -> pushed sync commit to ${branch}${prUrl ? ` (PR ${prUrl})` : ''}`;
+    } catch (e) {
+      // Same contract as the lane executor: a HALTED line, never a throw mid-run.
+      return `${_laneSyncExecutor().HALT_SUMMARY_PREFIX} main -> ${e?.message || e}`;
+    } finally {
+      await this.restoreWorkspace();
+    }
+  }
+
+  /**
+   * Put the working tree on the sync branch at a pristine copy of `startPoint`. Pristine is
+   * load-bearing for a diff-based reconciler: any stray modification would be indistinguishable from
+   * main-scope drift. The reload makes `checkout head` read this branch's `.bitmap`.
+   */
+  async resetToStartPoint(branch, startPoint) {
+    await (0, _gitOps().checkoutPristine)(branch, startPoint, () => this.deps.ci.reloadWorkspaceFromDisk());
+  }
+
+  /**
+   * Merge the default branch into the sync branch so drift is computed against the repository's
+   * current state. Returns a reason string on failure; a conflict needs a human (or deleting the sync
+   * branch, which the next run re-forks).
+   */
+  async catchUpWithDefaultBranch(branch) {
+    const {
+      defaultBranch,
+      logger
+    } = this.deps;
+    try {
+      // under the identity: a non-fast-forward merge writes a merge COMMIT
+      const out = await (0, _gitOps().gitWithIdentity)(['merge', '--no-edit', `origin/${defaultBranch}`]);
+      logger.console(_chalk().default.blue(`Brought ${branch} up to date with origin/${defaultBranch}: ${out.trim()}`));
+    } catch (e) {
+      await _git().git.raw(['merge', '--abort']).catch(() => undefined);
+      return `could not bring the sync branch ${branch} up to date with origin/${defaultBranch}: ${e?.message || e}. ` + `Resolve or delete ${branch} (a deleted sync branch is re-forked from ${defaultBranch} on the next run)`;
+    }
+    // The merge may have brought a new `.bitmap` in from the default branch.
+    await this.deps.ci.reloadWorkspaceFromDisk();
+    return undefined;
+  }
+
+  /**
+   * The "nothing to do" line — plus the open sync PR, if any: converged means the SYNC branch matches
+   * the scope, and the default branch may still differ until that PR merges.
+   */
+  async convergedSummary(branch) {
+    const {
+      gitHost
+    } = this.deps;
+    if (!gitHost) return CONVERGED_SUMMARY;
+    const pr = await gitHost.findPrByBranch(branch).catch(() => undefined);
+    return pr ? `${CONVERGED_SUMMARY} — open sync PR #${pr.number} still awaits review/merge` : CONVERGED_SUMMARY;
+  }
+
+  /**
+   * The files `bit checkout head` changed, i.e. the drift. Excludes `.bit`/`node_modules` — the same
+   * set the commit paths refuse to touch, keeping "counts as drift" and "gets committed" identical.
+   */
+  async driftFiles() {
+    const status = await _git().git.status();
+    const paths = status.files.map(file => file.path).filter(path => !(0, _gitOps().isNonContentPath)(path));
+    return [...new Set(paths)];
+  }
+
+  /**
+   * Make sure the pushed branch has an open PR. A git-host failure only warns: the branch is pushed,
+   * which is the load-bearing half, and the next run retries the PR.
+   */
+  async ensureSyncPr({
+    branch,
+    driftCount,
+    newFromScope
+  }) {
+    const {
+      gitHost,
+      logger,
+      defaultBranch
+    } = this.deps;
+    if (!gitHost) {
+      logger.consoleWarning('No configured git host provider (for GitHub: BIT_GITHUB_TOKEN or GITHUB_TOKEN, plus a repository) — ' + 'pushed sync branch, skipping PR operations');
+      return undefined;
+    }
+    try {
+      const existing = await gitHost.findPrByBranch(branch);
+      if (existing) {
+        logger.console(_chalk().default.blue(`Sync PR ${existing.htmlUrl} is already open — pushed the new commit onto it`));
+        return existing.htmlUrl;
+      }
+      const created = await gitHost.createPr({
+        head: branch,
+        base: defaultBranch,
+        title: 'Bit sync: update to latest main scope versions',
+        body: mainSyncPrBody({
+          driftCount,
+          newFromScope
+        })
+      });
+      logger.console(_chalk().default.green(`Opened sync PR ${created.htmlUrl}`));
+      return created.htmlUrl;
+    } catch (e) {
+      logger.consoleWarning(`Could not open or find the sync PR for ${branch}: ${e?.message || e}`);
+      return undefined;
+    }
+  }
+
+  /**
+   * Leave git on the default branch and bit on main. Mirrors `LaneSyncExecutor.restoreWorkspace`:
+   * best-effort and warn-only so a restore hiccup can't throw out of a `finally` and mask the real
+   * error; the clean discards untracked files `checkout head` wrote on the converged/dry-run paths.
+   */
+  async restoreWorkspace() {
+    const {
+      logger,
+      defaultBranch
+    } = this.deps;
+    try {
+      if ((0, _workspaceLane().currentLaneIdStr)(this.deps.lanes)) {
+        const switchErr = await this.deps.ci.switchToLaneForSync('main');
+        if (switchErr) logger.consoleWarning(`Could not switch the workspace back to main: ${switchErr.message}`);
+      }
+      await (0, _gitOps().checkoutPristineRestore)(defaultBranch, () => this.deps.ci.reloadWorkspaceFromDisk());
+    } catch (e) {
+      logger.consoleWarning(`Could not restore the workspace after the main sync: ${e?.message || e}`);
+    }
+  }
+}
+
+/** The sync commit message: no `Bit-Lane-Head` trailer — main sync keeps no state. */
+exports.MainSyncExecutor = MainSyncExecutor;
+function mainSyncCommitMessage(driftCount) {
+  return [`chore(bit-sync): sync git to latest main scope versions (${driftCount} file(s))`, '', _syncState().SYNC_COMMIT_MARKER].join('\n');
+}
+function mainSyncPrBody({
+  driftCount,
+  newFromScope
+}) {
+  const lines = ['Automated sync PR: the Bit scope moved ahead of this repository. This PR checks the workspace out to the ' + 'latest exported versions (`bit checkout head --auto-merge-resolve theirs`).', '', `- files changed: ${driftCount}`, '- conflicts between this repository and the scope were resolved **in favour of the scope** — if a file here ' + 'held changes that were never exported to Bit, this PR reverts them. Review the diff and close the PR ' + 'instead of merging if that is not what you want.'];
+  if (newFromScope.length) {
+    lines.push(`- components added from the scope (${newFromScope.length}, not previously in this repository's \`.bitmap\`):`,
+    // Bounded like the lane PR body: an over-long body is rejected by the host outright.
+    ...(0, _laneSyncExecutor().capEntries)(newFromScope.map(id => `  - \`${id}\``), '  - '));
+  }
+  lines.push('', 'This PR is maintained by `bit ci sync` — re-running the command pushes any further drift onto the same branch.');
+  return lines.join('\n');
+}
+
+//# sourceMappingURL=main-sync-executor.js.map

package/dist/sync/main-sync-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chalk","data","_interopRequireDefault","require","_cli","_git","_syncState","_workspaceLane","_laneSyncExecutor","_gitOps","e","__esModule","default","CONVERGED_SUMMARY","MainSyncExecutor","constructor","deps","syncMain","opts","cfg","defaultBranch","defaultScope","logger","directPush","mainSync","branch","mainSyncBranch","autoMergeMainSyncPr","consoleWarning","fetchRemoteHeads","syncBranchExists","branchExistsOnRemote","startPoint","console","chalk","blue","resetToStartPoint","catchUpErr","catchUpWithDefaultBranch","HALT_SUMMARY_PREFIX","currentLane","currentLaneIdStr","lanes","results","checkout","checkoutByCLIValues","head","skipNpmInstall","includeNewFromScope","mergeStrategy","newFromScope","length","join","drift","driftFiles","convergedSummary","formatWarningSummary","slice","dryRun","addAllExceptScopeAndModules","commitWithIdentity","mainSyncCommitMessage","git","push","green","shortSha","revparse","trim","prUrl","ensureSyncPr","driftCount","message","restoreWorkspace","checkoutPristine","ci","reloadWorkspaceFromDisk","out","gitWithIdentity","raw","catch","undefined","gitHost","pr","findPrByBranch","number","status","paths","files","map","file","path","filter","isNonContentPath","Set","existing","htmlUrl","created","createPr","base","title","body","mainSyncPrBody","switchErr","switchToLaneForSync","checkoutPristineRestore","exports","SYNC_COMMIT_MARKER","lines","capEntries","id"],"sources":["main-sync-executor.ts"],"sourcesContent":["import chalk from 'chalk';\nimport { formatWarningSummary } from '@teambit/cli';\nimport type { Logger } from '@teambit/logger';\nimport type { LanesMain } from '@teambit/lanes';\nimport type { CheckoutMain } from '@teambit/checkout';\nimport { git } from '../git';\nimport type { CiMain } from '../ci.main.runtime';\nimport type { CiSyncConfig } from './sync-config';\nimport { SYNC_COMMIT_MARKER } from './sync-state';\nimport { currentLaneIdStr } from './workspace-lane';\nimport type { GitHostProvider } from './git-host-provider';\nimport { HALT_SUMMARY_PREFIX, capEntries } from './lane-sync-executor';\nimport {\n  addAllExceptScopeAndModules,\n  branchExistsOnRemote,\n  checkoutPristine,\n  checkoutPristineRestore,\n  commitWithIdentity,\n  fetchRemoteHeads,\n  gitWithIdentity,\n  isNonContentPath,\n} from './git-ops';\n\nexport type MainSyncDeps = {\n  checkout: CheckoutMain;\n  lanes: LanesMain;\n  /** for reloadWorkspaceFromDisk + switchToLaneForSync */\n  ci: CiMain;\n  logger: Logger;\n  /** undefined => PR operations are logged and skipped; the git half of the sync still runs. */\n  gitHost?: GitHostProvider;\n  cfg: Required<CiSyncConfig>;\n  defaultBranch: string;\n  defaultScope: string;\n};\n\n/**\n * Reconcile the main scope with the repository's default branch. Stateless: `bit checkout head`\n * writes the latest exported versions, so an empty `git status` IS convergence and any diff IS the\n * drift. Under 'pr' the convergence is proposed via `mainSyncBranch`; under 'direct-push' it lands on\n * the default branch with a plain push. Nothing is ever force-pushed in either mode.\n */\n/** the \"nothing to do\" line, shared by both modes */\nconst CONVERGED_SUMMARY = 'main -> converged (checkout head produced no changes)';\n\nexport class MainSyncExecutor {\n  constructor(private deps: MainSyncDeps) {}\n\n  /**\n   * Returns a summary line (HALT-prefixed on failure) and, like `syncLane`, does not throw — a\n   * main-sync failure must not erase the lane results collected before it.\n   */\n  async syncMain(opts: { dryRun?: boolean } = {}): Promise<string> {\n    const { cfg, defaultBranch, defaultScope, logger } = this.deps;\n    const directPush = cfg.mainSync === 'direct-push';\n    // In direct-push mode the sync branch (and its PR) is not consulted, moved or deleted.\n    const branch = directPush ? defaultBranch : cfg.mainSyncBranch;\n\n    if (cfg.autoMergeMainSyncPr && !directPush) {\n      // Enabling auto-merge is host-specific and not part of the GitHostProvider contract.\n      logger.consoleWarning(\n        `sync.autoMergeMainSyncPr is enabled in the config, but enabling auto-merge is not implemented yet — ` +\n          `the sync PR is opened without it. Use a repository auto-merge rule instead.`\n      );\n    }\n\n    try {\n      await fetchRemoteHeads();\n      // Direct-push always starts from `origin/<defaultBranch>` — the very tip the plain push must\n      // fast-forward. In 'pr' mode an existing sync branch is reused so its PR history survives.\n      const syncBranchExists = directPush ? false : await branchExistsOnRemote(branch);\n      const startPoint = syncBranchExists ? `origin/${branch}` : `origin/${defaultBranch}`;\n      logger.console(\n        chalk.blue(\n          directPush\n            ? `main -> checking the main scope against ${defaultBranch} (direct-push)`\n            : `main -> checking the main scope against ${defaultBranch} (sync branch ${branch})`\n        )\n      );\n\n      await this.resetToStartPoint(branch, startPoint);\n\n      if (syncBranchExists) {\n        // Catch up with the default branch: the PR must stay mergeable, and `checkout head` on a stale\n        // tree would re-commit pre-merge content over the default branch's changes. A merge — never a\n        // rebase, never a force-push — is the only non-destructive way to move a branch with an open PR.\n        const catchUpErr = await this.catchUpWithDefaultBranch(branch);\n        if (catchUpErr) return `${HALT_SUMMARY_PREFIX} main -> ${catchUpErr}`;\n      }\n\n      // `checkout head` resolves versions against the CURRENT lane; a lane pointer on this branch\n      // would make the \"drift\" the lane's content. Refuse rather than open a wildly wrong PR.\n      // `.bitmap`-derived read: the scope-object read answers \"main\" on a fresh runner and the guard\n      // would silently stop refusing exactly where it ships (see `workspace-lane.ts`).\n      const currentLane = currentLaneIdStr(this.deps.lanes);\n      if (currentLane) {\n        return (\n          `${HALT_SUMMARY_PREFIX} main -> the .bitmap on ${startPoint} points at lane ` +\n          `\"${currentLane}\" rather than main, so the main-scope drift cannot be computed`\n        );\n      }\n\n      // `checkoutByCLIValues` rather than `checkout`: it imports current objects first (so `head`\n      // resolves to the remote scope's versions) and persists `.bitmap` on destroy.\n      // `includeNewFromScope`: a component exported to the scope's main but never in this repo's\n      // `.bitmap` would otherwise be invisible to every sync run forever.\n      // `mergeStrategy: 'theirs'` is required: unexported source drift makes components \"modified\",\n      // and with no strategy the checkout throws. 'theirs' materializes the exported truth — any\n      // reversion of unexported drift is visible in the PR diff. 'ours' is forbidden: it would advance\n      // `.bitmap` while keeping the old files, a commit asserting a state the tree does not have.\n      const results = await this.deps.checkout.checkoutByCLIValues('', {\n        head: true,\n        skipNpmInstall: true,\n        includeNewFromScope: true,\n        mergeStrategy: 'theirs',\n      });\n      const newFromScope = results.newFromScope ?? [];\n      if (newFromScope.length) {\n        logger.console(\n          chalk.blue(\n            `Added ${newFromScope.length} component(s) that exist on ${defaultScope}'s main but not in this ` +\n              `workspace: ${newFromScope.join(', ')}`\n          )\n        );\n      }\n\n      const drift = await this.driftFiles();\n      // Direct-push stays bare: asking the host about `mainSyncBranch`'s PR would be the one\n      // interaction with it this mode promises not to make.\n      if (!drift.length) return directPush ? CONVERGED_SUMMARY : await this.convergedSummary(branch);\n\n      logger.console(\n        formatWarningSummary(`main -> drift in ${drift.length} file(s): ${drift.slice(0, 20).join(', ')}`)\n      );\n\n      if (opts.dryRun) {\n        // The working tree WAS written (a diff-based check has no other way); `finally` restores it. Safe\n        // only because a dry run over a dirty tree is refused before anything runs — the restore rewinds\n        // to HEAD, so an uncommitted change here would be gone (`assertCleanForDryRun`).\n        logger.console(\n          formatWarningSummary(\n            directPush\n              ? `Dry-run: main -> would push the drift directly onto ${branch}`\n              : `Dry-run: main -> would push ${branch} and open a sync PR`\n          )\n        );\n        return directPush\n          ? `main -> drift detected in ${drift.length} file(s) — would push ${branch} directly`\n          : `main -> drift detected in ${drift.length} file(s) — would open sync PR`;\n      }\n\n      await addAllExceptScopeAndModules();\n      await commitWithIdentity(mainSyncCommitMessage(drift.length));\n      // Never force: a rejected push means a concurrent run pushed in between, and in direct-push mode\n      // that rejection is the whole safety story for the default branch. Unambiguous refspec — see\n      // `lane-sync-executor.commitAllAndPush`.\n      await git.push(['origin', `HEAD:refs/heads/${branch}`]);\n      logger.console(chalk.green(`Pushed ${branch}`));\n\n      if (directPush) {\n        const shortSha = (await git.revparse(['--short', 'HEAD'])).trim();\n        return `main -> direct-push (pushed ${branch} @ ${shortSha})`;\n      }\n      const prUrl = await this.ensureSyncPr({ branch, driftCount: drift.length, newFromScope });\n      return `main -> pushed sync commit to ${branch}${prUrl ? ` (PR ${prUrl})` : ''}`;\n    } catch (e: any) {\n      // Same contract as the lane executor: a HALTED line, never a throw mid-run.\n      return `${HALT_SUMMARY_PREFIX} main -> ${e?.message || e}`;\n    } finally {\n      await this.restoreWorkspace();\n    }\n  }\n\n  /**\n   * Put the working tree on the sync branch at a pristine copy of `startPoint`. Pristine is\n   * load-bearing for a diff-based reconciler: any stray modification would be indistinguishable from\n   * main-scope drift. The reload makes `checkout head` read this branch's `.bitmap`.\n   */\n  private async resetToStartPoint(branch: string, startPoint: string) {\n    await checkoutPristine(branch, startPoint, () => this.deps.ci.reloadWorkspaceFromDisk());\n  }\n\n  /**\n   * Merge the default branch into the sync branch so drift is computed against the repository's\n   * current state. Returns a reason string on failure; a conflict needs a human (or deleting the sync\n   * branch, which the next run re-forks).\n   */\n  private async catchUpWithDefaultBranch(branch: string): Promise<string | undefined> {\n    const { defaultBranch, logger } = this.deps;\n    try {\n      // under the identity: a non-fast-forward merge writes a merge COMMIT\n      const out = await gitWithIdentity(['merge', '--no-edit', `origin/${defaultBranch}`]);\n      logger.console(chalk.blue(`Brought ${branch} up to date with origin/${defaultBranch}: ${out.trim()}`));\n    } catch (e: any) {\n      await git.raw(['merge', '--abort']).catch(() => undefined);\n      return (\n        `could not bring the sync branch ${branch} up to date with origin/${defaultBranch}: ${e?.message || e}. ` +\n        `Resolve or delete ${branch} (a deleted sync branch is re-forked from ${defaultBranch} on the next run)`\n      );\n    }\n    // The merge may have brought a new `.bitmap` in from the default branch.\n    await this.deps.ci.reloadWorkspaceFromDisk();\n    return undefined;\n  }\n\n  /**\n   * The \"nothing to do\" line — plus the open sync PR, if any: converged means the SYNC branch matches\n   * the scope, and the default branch may still differ until that PR merges.\n   */\n  private async convergedSummary(branch: string): Promise<string> {\n    const { gitHost } = this.deps;\n    if (!gitHost) return CONVERGED_SUMMARY;\n    const pr = await gitHost.findPrByBranch(branch).catch(() => undefined);\n    return pr ? `${CONVERGED_SUMMARY} — open sync PR #${pr.number} still awaits review/merge` : CONVERGED_SUMMARY;\n  }\n\n  /**\n   * The files `bit checkout head` changed, i.e. the drift. Excludes `.bit`/`node_modules` — the same\n   * set the commit paths refuse to touch, keeping \"counts as drift\" and \"gets committed\" identical.\n   */\n  private async driftFiles(): Promise<string[]> {\n    const status = await git.status();\n    const paths = status.files.map((file) => file.path).filter((path) => !isNonContentPath(path));\n    return [...new Set(paths)];\n  }\n\n  /**\n   * Make sure the pushed branch has an open PR. A git-host failure only warns: the branch is pushed,\n   * which is the load-bearing half, and the next run retries the PR.\n   */\n  private async ensureSyncPr({\n    branch,\n    driftCount,\n    newFromScope,\n  }: {\n    branch: string;\n    driftCount: number;\n    newFromScope: string[];\n  }): Promise<string | undefined> {\n    const { gitHost, logger, defaultBranch } = this.deps;\n    if (!gitHost) {\n      logger.consoleWarning(\n        'No configured git host provider (for GitHub: BIT_GITHUB_TOKEN or GITHUB_TOKEN, plus a repository) — ' +\n          'pushed sync branch, skipping PR operations'\n      );\n      return undefined;\n    }\n    try {\n      const existing = await gitHost.findPrByBranch(branch);\n      if (existing) {\n        logger.console(chalk.blue(`Sync PR ${existing.htmlUrl} is already open — pushed the new commit onto it`));\n        return existing.htmlUrl;\n      }\n      const created = await gitHost.createPr({\n        head: branch,\n        base: defaultBranch,\n        title: 'Bit sync: update to latest main scope versions',\n        body: mainSyncPrBody({ driftCount, newFromScope }),\n      });\n      logger.console(chalk.green(`Opened sync PR ${created.htmlUrl}`));\n      return created.htmlUrl;\n    } catch (e: any) {\n      logger.consoleWarning(`Could not open or find the sync PR for ${branch}: ${e?.message || e}`);\n      return undefined;\n    }\n  }\n\n  /**\n   * Leave git on the default branch and bit on main. Mirrors `LaneSyncExecutor.restoreWorkspace`:\n   * best-effort and warn-only so a restore hiccup can't throw out of a `finally` and mask the real\n   * error; the clean discards untracked files `checkout head` wrote on the converged/dry-run paths.\n   */\n  private async restoreWorkspace() {\n    const { logger, defaultBranch } = this.deps;\n    try {\n      if (currentLaneIdStr(this.deps.lanes)) {\n        const switchErr = await this.deps.ci.switchToLaneForSync('main');\n        if (switchErr) logger.consoleWarning(`Could not switch the workspace back to main: ${switchErr.message}`);\n      }\n      await checkoutPristineRestore(defaultBranch, () => this.deps.ci.reloadWorkspaceFromDisk());\n    } catch (e: any) {\n      logger.consoleWarning(`Could not restore the workspace after the main sync: ${e?.message || e}`);\n    }\n  }\n}\n\n/** The sync commit message: no `Bit-Lane-Head` trailer — main sync keeps no state. */\nfunction mainSyncCommitMessage(driftCount: number): string {\n  return [\n    `chore(bit-sync): sync git to latest main scope versions (${driftCount} file(s))`,\n    '',\n    SYNC_COMMIT_MARKER,\n  ].join('\\n');\n}\n\nfunction mainSyncPrBody({ driftCount, newFromScope }: { driftCount: number; newFromScope: string[] }): string {\n  const lines = [\n    'Automated sync PR: the Bit scope moved ahead of this repository. This PR checks the workspace out to the ' +\n      'latest exported versions (`bit checkout head --auto-merge-resolve theirs`).',\n    '',\n    `- files changed: ${driftCount}`,\n    '- conflicts between this repository and the scope were resolved **in favour of the scope** — if a file here ' +\n      'held changes that were never exported to Bit, this PR reverts them. Review the diff and close the PR ' +\n      'instead of merging if that is not what you want.',\n  ];\n  if (newFromScope.length) {\n    lines.push(\n      `- components added from the scope (${newFromScope.length}, not previously in this repository's \\`.bitmap\\`):`,\n      // Bounded like the lane PR body: an over-long body is rejected by the host outright.\n      ...capEntries(\n        newFromScope.map((id) => `  - \\`${id}\\``),\n        '  - '\n      )\n    );\n  }\n  lines.push(\n    '',\n    'This PR is maintained by `bit ci sync` — re-running the command pushes any further drift onto the same branch.'\n  );\n  return lines.join('\\n');\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/sync/sync-config.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Is this a branch name git will accept? A conservative pure subset of `git check-ref-format --branch`:
+ * stricter than git is fine, laxer is not. A leading `-` must be refused here because it would be read
+ * as a command-line option once interpolated into a git invocation.
+ */
+export declare function isValidGitBranchName(name: string): boolean;
+/** Why `name` is not a usable branch name, or undefined when it is. */
+export declare function validateBranchName(name: string): string | undefined;
+/** Throw a `BitError` naming the offending config key and value unless `name` is a usable branch name. */
+export declare function assertValidBranchName(name: string, configKey: string): void;
+/**
+ * A `branchPrefix` may end in `/` or be empty, so it is validated as the *start* of a branch name.
+ * The full check still happens on the derived name (see `laneNameToBranch`).
+ */
+export declare function assertValidBranchPrefix(prefix: string, configKey: string): void;
+export interface CiSyncConfig {
+    /** The prefix for a lane-mapped branch. 'lane/' maps lane my-lane to branch lane/my-lane. */
+    branchPrefix?: string;
+    /** Explicit overrides that map a lane name to a branch name. */
+    branches?: Record<string, string>;
+    /** The glob patterns of the lane names to sync. An empty list stops lane mirroring. */
+    lanes?: string[];
+    /** The branch that carries the main-scope drift. */
+    mainSyncBranch?: string;
+    /**
+     * How main-scope drift reaches the default branch. 'pr' (the default): the command commits the drift
+     * to `mainSyncBranch` and opens a pull request. 'direct-push': the command commits the drift on the
+     * default branch and pushes it, and does not use `mainSyncBranch`.
+     */
+    mainSync?: 'pr' | 'direct-push';
+    /**
+     * What the command does with one contested line during a `merge-diverged` action. 'halt' (the
+     * default): the command stops, labels the pull request, and writes the recovery steps. 'git-wins':
+     * the command keeps the branch version. 'lane-wins': the command takes the lane version.
+     * Non-conflicting changes always merge, with every value.
+     */
+    onConflict?: 'halt' | 'git-wins' | 'lane-wins';
+    /** Reserved. The command warns and enables no auto-merge on the main sync pull request. */
+    autoMergeMainSyncPr?: boolean;
+}
+/**
+ * Resolve the configured sync options, validating every branch name before anything runs — a bad name
+ * must fail at startup naming the config key, not mid-run with git's own ref error.
+ */
+export declare function resolveSyncConfig(raw?: CiSyncConfig): Required<CiSyncConfig>;
+/**
+ * The branch a lane name maps to. The derived result is validated too: a prefix that is fine on its
+ * own can still combine with a lane name into something git refuses.
+ */
+export declare function laneNameToBranch(laneName: string, cfg: Required<CiSyncConfig>): string;
+export declare function branchToLaneName(branch: string, cfg: Required<CiSyncConfig>): string | undefined;
+/**
+ * A lane to sync, split into the scope hosting the lane object and the bare name. The branch mapping
+ * uses the NAME only; every bit operation uses the full `hostScope/name`.
+ */
+export type LaneTarget = {
+    /** the scope hosting the lane object; the workspace's defaultScope unless the target said otherwise */
+    hostScope: string;
+    /** the bare lane name — never contains a '/' */
+    name: string;
+};
+/**
+ * Parse the `[lane]` argument (`my-lane` or `some-org.some-scope/my-lane`) into a {@link LaneTarget}.
+ * A lane name cannot contain `/`, so the single `/` is always the scope/name boundary. The dot in a
+ * scope id is not required (self-hosted scopes can be bare names), so it is not validated here.
+ */
+export declare function parseLaneTarget(input: string, defaultScope: string): LaneTarget;
+/**
+ * The lane name a branch maps to, only if that name could actually be a lane AND maps back to a branch
+ * name usable in a git invocation. `branchToLaneName` alone is a string transform (the identity under
+ * the default empty prefix), so it would report `feature/foo` as a "lane" — a name bit forbids. The
+ * round trip matters because the lane grammar permits `-`: a developer branch called `-x` is a valid
+ * lane name, so enumeration would adopt it as a target and the branch mapping would then throw, turning
+ * one oddly-named branch into a halt that fails the whole `--all` run. Such a branch is not lane-mapped;
+ * skip it like any other.
+ */
+export declare function syncableLaneNameForBranch(branch: string, cfg: Required<CiSyncConfig>): string | undefined;
+/**
+ * Could this string be a bit lane name at all? Mirrors the module-private `isValidLaneName` in
+ * `create-lane.ts`; drift errs toward skipping a branch, and `sync-config.spec.ts` pins the rule.
+ */
+export declare function isValidLaneName(name: string): boolean;
+export declare function shouldSyncLane(laneName: string, cfg: Required<CiSyncConfig>): boolean;

package/dist/sync/sync-config.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertValidBranchName = assertValidBranchName;
+exports.assertValidBranchPrefix = assertValidBranchPrefix;
+exports.branchToLaneName = branchToLaneName;
+exports.isValidGitBranchName = isValidGitBranchName;
+exports.isValidLaneName = isValidLaneName;
+exports.laneNameToBranch = laneNameToBranch;
+exports.parseLaneTarget = parseLaneTarget;
+exports.resolveSyncConfig = resolveSyncConfig;
+exports.shouldSyncLane = shouldSyncLane;
+exports.syncableLaneNameForBranch = syncableLaneNameForBranch;
+exports.validateBranchName = validateBranchName;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * Is this a branch name git will accept? A conservative pure subset of `git check-ref-format --branch`:
+ * stricter than git is fine, laxer is not. A leading `-` must be refused here because it would be read
+ * as a command-line option once interpolated into a git invocation.
+ */
+function isValidGitBranchName(name) {
+  return validateBranchName(name) === undefined;
+}
+
+/** Why `name` is not a usable branch name, or undefined when it is. */
+function validateBranchName(name) {
+  if (!name) return 'it is empty';
+  if (name.startsWith('-')) return 'it starts with "-", which git would read as a command-line option';
+  if (/\s/.test(name)) return 'it contains whitespace';
+  // oxlint-disable-next-line no-control-regex
+  if (/[\x00-\x1f\x7f]/.test(name)) return 'it contains a control character';
+  if (/[~^:?*[\\]/.test(name)) return 'it contains one of the characters git forbids in a ref: ~ ^ : ? * [ \\';
+  if (name.includes('..')) return 'it contains ".."';
+  if (name.includes('@{')) return 'it contains "@{"';
+  if (name === '@') return 'it is "@", which git reserves';
+  // Leading `refs/` only: pushes interpolate the name into `refs/heads/<b>`, so it would double up.
+  if (name.startsWith('refs/')) return 'it starts with "refs/" — configure the bare branch name ("main", not "refs/heads/main")';
+  if (name.startsWith('/') || name.endsWith('/')) return 'it starts or ends with "/"';
+  if (name.includes('//')) return 'it contains an empty path component ("//")';
+  if (name.endsWith('.')) return 'it ends with "."';
+  if (name.endsWith('.lock')) return 'it ends with ".lock"';
+  if (name.split('/').some(component => component.startsWith('.'))) return 'a path component starts with "."';
+  if (name.split('/').some(component => component.endsWith('.lock'))) return 'a path component ends with ".lock"';
+  return undefined;
+}
+
+/** Throw a `BitError` naming the offending config key and value unless `name` is a usable branch name. */
+function assertValidBranchName(name, configKey) {
+  const problem = validateBranchName(name);
+  if (!problem) return;
+  throw new (_bitError().BitError)(`bit ci sync: ${configKey} is "${name}", which is not a valid git branch name — ${problem}. ` + `Fix it in the "teambit.git/ci" sync config in workspace.jsonc.`);
+}
+
+/**
+ * A `branchPrefix` may end in `/` or be empty, so it is validated as the *start* of a branch name.
+ * The full check still happens on the derived name (see `laneNameToBranch`).
+ */
+function assertValidBranchPrefix(prefix, configKey) {
+  if (!prefix) return;
+  const problem = validateBranchName(`${prefix}x`);
+  if (!problem) return;
+  throw new (_bitError().BitError)(`bit ci sync: ${configKey} is "${prefix}", which cannot start a valid git branch name — ${problem}. ` + `Fix it in the "teambit.git/ci" sync config in workspace.jsonc.`);
+}
+/**
+ * Resolve the configured sync options, validating every branch name before anything runs — a bad name
+ * must fail at startup naming the config key, not mid-run with git's own ref error.
+ */
+function resolveSyncConfig(raw) {
+  const resolved = {
+    branchPrefix: raw?.branchPrefix ?? '',
+    branches: raw?.branches ?? {},
+    lanes: raw?.lanes ?? ['*'],
+    mainSyncBranch: raw?.mainSyncBranch ?? 'bit-sync/main',
+    autoMergeMainSyncPr: raw?.autoMergeMainSyncPr ?? false,
+    mainSync: raw?.mainSync ?? 'pr',
+    onConflict: raw?.onConflict ?? 'halt'
+  };
+  // Config comes from workspace.jsonc, so the union types are not enforced at runtime; a typo must
+  // fail at startup rather than fall through to whichever mode a comparison happens to miss.
+  if (resolved.mainSync !== 'pr' && resolved.mainSync !== 'direct-push') {
+    throw new (_bitError().BitError)(`sync.mainSync: "${resolved.mainSync}" is not a valid value. Use "pr" (propose the main-scope drift ` + `as a pull request from sync.mainSyncBranch) or "direct-push" (push the drift straight onto the ` + `default branch)`);
+  }
+  if (resolved.onConflict !== 'halt' && resolved.onConflict !== 'git-wins' && resolved.onConflict !== 'lane-wins') {
+    throw new (_bitError().BitError)(`sync.onConflict: "${resolved.onConflict}" is not a valid value. Use "halt" (stop the conflicted ` + `lane, label the PR and let a human resolve — the default), "git-wins" (conflicting hunks keep ` + `the branch's version) or "lane-wins" (conflicting hunks take the lane's version)`);
+  }
+  assertValidBranchPrefix(resolved.branchPrefix, 'sync.branchPrefix');
+  assertValidBranchName(resolved.mainSyncBranch, 'sync.mainSyncBranch');
+  Object.entries(resolved.branches).forEach(([laneName, branch]) => assertValidBranchName(branch, `sync.branches["${laneName}"]`));
+  return resolved;
+}
+
+/**
+ * The branch a lane name maps to. The derived result is validated too: a prefix that is fine on its
+ * own can still combine with a lane name into something git refuses.
+ */
+function laneNameToBranch(laneName, cfg) {
+  const override = cfg.branches[laneName];
+  if (override) return override; // already validated by resolveSyncConfig
+  const derived = `${cfg.branchPrefix}${laneName}`;
+  assertValidBranchName(derived, `the branch for lane "${laneName}" (sync.branchPrefix + lane name)`);
+  return derived;
+}
+function branchToLaneName(branch, cfg) {
+  const override = Object.entries(cfg.branches).find(([, b]) => b === branch);
+  if (override) return override[0];
+  if (cfg.branchPrefix) {
+    return branch.startsWith(cfg.branchPrefix) ? branch.slice(cfg.branchPrefix.length) : undefined;
+  }
+  return branch;
+}
+
+/**
+ * A lane to sync, split into the scope hosting the lane object and the bare name. The branch mapping
+ * uses the NAME only; every bit operation uses the full `hostScope/name`.
+ */
+
+/**
+ * Parse the `[lane]` argument (`my-lane` or `some-org.some-scope/my-lane`) into a {@link LaneTarget}.
+ * A lane name cannot contain `/`, so the single `/` is always the scope/name boundary. The dot in a
+ * scope id is not required (self-hosted scopes can be bare names), so it is not validated here.
+ */
+function parseLaneTarget(input, defaultScope) {
+  const trimmed = input.trim();
+  if (!trimmed) throw new (_bitError().BitError)('bit ci sync: the lane argument is empty');
+  if (!trimmed.includes('/')) return {
+    hostScope: defaultScope,
+    name: trimmed
+  };
+  const parts = trimmed.split('/');
+  const [hostScope, name] = parts;
+  if (parts.length !== 2 || !hostScope || !name) {
+    throw new (_bitError().BitError)(`bit ci sync: "${input}" is not a valid lane target. Use either a lane name ("my-lane", resolved ` + `against the workspace's defaultScope "${defaultScope}") or a scope-qualified lane id ` + `("some-org.some-scope/my-lane")`);
+  }
+  return {
+    hostScope,
+    name
+  };
+}
+
+/**
+ * The lane name a branch maps to, only if that name could actually be a lane AND maps back to a branch
+ * name usable in a git invocation. `branchToLaneName` alone is a string transform (the identity under
+ * the default empty prefix), so it would report `feature/foo` as a "lane" — a name bit forbids. The
+ * round trip matters because the lane grammar permits `-`: a developer branch called `-x` is a valid
+ * lane name, so enumeration would adopt it as a target and the branch mapping would then throw, turning
+ * one oddly-named branch into a halt that fails the whole `--all` run. Such a branch is not lane-mapped;
+ * skip it like any other.
+ */
+function syncableLaneNameForBranch(branch, cfg) {
+  const laneName = branchToLaneName(branch, cfg);
+  if (!laneName || !isValidLaneName(laneName)) return undefined;
+  // `laneNameToBranch` asserts rather than returns, so the round trip is checked here: a configured
+  // override is already validated, and a derived name must pass the same branch-name rules.
+  if (cfg.branches[laneName]) return laneName;
+  return validateBranchName(`${cfg.branchPrefix}${laneName}`) === undefined ? laneName : undefined;
+}
+
+/** bit's own maximum lane-name length (`create-lane.ts`'s `MAX_LANE_NAME_LENGTH`). */
+const MAX_LANE_NAME_LENGTH = 800;
+
+/**
+ * Could this string be a bit lane name at all? Mirrors the module-private `isValidLaneName` in
+ * `create-lane.ts`; drift errs toward skipping a branch, and `sync-config.spec.ts` pins the rule.
+ */
+function isValidLaneName(name) {
+  if (!name || name.length > MAX_LANE_NAME_LENGTH) return false;
+  return /^[$\-_!a-z0-9]+$/.test(name);
+}
+
+/** minimal glob: '*' wildcard only (matches the lanes list use-case; avoids a new dep) */
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+  return new RegExp(`^${escaped}$`);
+}
+function shouldSyncLane(laneName, cfg) {
+  return cfg.lanes.some(pattern => globToRegExp(pattern).test(laneName));
+}
+
+//# sourceMappingURL=sync-config.js.map