@teambit/ci 1.0.485 → 1.0.486

package/dist/ci.main.runtime.d.ts

@@ -1,16 +1,23 @@
-import type { RuntimeDefinition } from '@teambit/harmony';
+import type { RuntimeDefinition, SlotRegistry } from '@teambit/harmony';
 import { type CLIMain } from '@teambit/cli';
 import { type LoggerMain, type Logger } from '@teambit/logger';
 import { type Workspace } from '@teambit/workspace';
 import { type BuilderMain } from '@teambit/builder';
 import { type StatusMain } from '@teambit/status';
-import type { LanesMain } from '@teambit/lanes';
+import type { SwitchLaneOptions, LanesMain } from '@teambit/lanes';
 import type { SnappingMain } from '@teambit/snapping';
 import { type ExportMain } from '@teambit/export';
 import { type ImporterMain } from '@teambit/importer';
 import { type CheckoutMain } from '@teambit/checkout';
 import type { MergeStrategy } from '@teambit/component.modules.merge-helper';
 import type { ReleaseType } from 'semver';
+import type { CiSyncConfig } from './sync/sync-config';
+import type { GitHostProvider } from './sync/git-host-provider';
+/**
+ * Registered git hosts (GitHub ships built-in; others register from their own aspect).
+ * @see GitHostProvider
+ */
+export type GitHostProviderSlot = SlotRegistry<GitHostProvider>;
 export interface CiWorkspaceConfig {
     /**
      * Path to a custom script that generates commit messages for `bit ci merge` operations.
@@ -68,6 +75,12 @@ export interface CiWorkspaceConfig {
      * ```
      */
     useExplicitBumpKeywords?: boolean;
+    /**
+     * Configuration for `bit ci sync` — bi-directional lane <-> branch/PR sync.
+     * See CiSyncConfig for fields. Example:
+     * { "teambit.git/ci": { "sync": { "branchPrefix": "lane/", "lanes": ["*"] } } }
+     */
+    sync?: CiSyncConfig;
 }
 export declare class CiMain {
     private workspace;
@@ -80,10 +93,11 @@ export declare class CiMain {
     private checkout;
     private logger;
     private config;
+    private gitHostProviderSlot;
     static runtime: RuntimeDefinition;
     static dependencies: any;
-    static slots: any;
-    constructor(workspace: Workspace, builder: BuilderMain, status: StatusMain, lanes: LanesMain, snapping: SnappingMain, exporter: ExportMain, importer: ImporterMain, checkout: CheckoutMain, logger: Logger, config: CiWorkspaceConfig);
+    static slots: ((registerFn: () => string) => SlotRegistry<GitHostProvider>)[];
+    constructor(workspace: Workspace, builder: BuilderMain, status: StatusMain, lanes: LanesMain, snapping: SnappingMain, exporter: ExportMain, importer: ImporterMain, checkout: CheckoutMain, logger: Logger, config: CiWorkspaceConfig, gitHostProviderSlot: GitHostProviderSlot);
     static provider([cli, workspace, loggerAspect, builder, status, lanes, snapping, exporter, importer, checkout]: [
         CLIMain,
         Workspace,
@@ -95,7 +109,16 @@ export declare class CiMain {
         ExportMain,
         ImporterMain,
         CheckoutMain
-    ], config: CiWorkspaceConfig): Promise<CiMain>;
+    ], config: CiWorkspaceConfig, [gitHostProviderSlot]: [GitHostProviderSlot]): Promise<CiMain>;
+    /**
+     * Register a git host (GitHub, GitLab, …) that `bit ci sync` can use for its pull-request
+     * operations. Exactly one provider is selected per run, by the `origin` remote (see
+     * `selectGitHostProvider`); registering a provider never changes how a repository claimed by a
+     * different provider is handled.
+     */
+    registerGitHostProvider(provider: GitHostProvider): this;
+    /** Every registered git host provider, in registration order (one provider per registration). */
+    listGitHostProviders(): GitHostProvider[];
     getBranchName(): Promise<string>;
     private getCirclePullRequestBranchName;
     /**
@@ -108,7 +131,16 @@ export declare class CiMain {
      * @example convertBranchToLaneId("feature/New-Component") => "my-scope/feature-new-component"
      */
     convertBranchToLaneId(branchName: string): string;
+    /**
+     * The repository's default branch name, whole — slashes included (see `parseOriginHeadRef`).
+     * Local `origin/HEAD` symref first, then the remote's own answer, then the conventional probe.
+     */
     getDefaultBranchName(): Promise<string>;
+    /**
+     * Last-resort fallback: the two conventional names among the remote branches, then `master`.
+     * Deliberately only `main`/`master` — any wider guess risks protecting the wrong branch.
+     */
+    private probeDefaultBranchName;
     getGitCommitMessage(): Promise<string | null>;
     private parseVersionBumpFromCommit;
     private getCustomCommitMessage;
@@ -120,6 +152,27 @@ export declare class CiMain {
      * `getCurrentLane()` check.
      */
     private switchToLane;
+    /**
+     * Public entry point onto `switchToLane` for the lane-sync executor; returns the error instead of
+     * throwing. `switchToLane` spreads caller options AFTER its defaults, so `forceOurs: true` is
+     * overridable — the sync import direction depends on that. Do not reorder that spread.
+     */
+    switchToLaneForSync(laneName: string, options?: SwitchLaneOptions): Promise<Error | undefined>;
+    /**
+     * Re-read `.bitmap` from disk into the live workspace. `bit ci sync` moves the git checkout
+     * underneath a running process, and until the reload every bit operation resolves against the
+     * `.bitmap` loaded at startup — and the next write would persist that stale state.
+     */
+    reloadWorkspaceFromDisk(): Promise<void>;
+    /** `bit ci sync` — reconcile Bit lanes and the main scope with git branches and PRs (see `SyncOrchestrator`). */
+    sync(opts?: {
+        lane?: string;
+        branch?: string;
+        all?: boolean;
+        main?: boolean;
+        dryRun?: boolean;
+        init?: boolean;
+    }): Promise<string>;
     /**
      * Sync *config-only* changes from main onto the lane — without a full `bit lane merge`.
      *
@@ -171,7 +224,7 @@ export declare class CiMain {
         code: number;
         data: string;
     }>;
-    snapPrCommit({ laneIdStr, message, build, strict, dryRun, keepLane, skipCleanup, skipTasks, }: {
+    snapPrCommit({ laneIdStr, message, build, strict, dryRun, keepLane, skipCleanup, skipTasks, noDestructiveRecovery, }: {
         laneIdStr: string;
         message: string;
         build: boolean | undefined;
@@ -180,6 +233,14 @@ export declare class CiMain {
         keepLane?: boolean;
         skipCleanup?: boolean;
         skipTasks?: string;
+        /**
+         * Opt out of the `--keep-lane` stale-lane recovery that deletes the remote lane and recreates it
+         * from main. That trade is fine for a PR lane (a throwaway mirror of a git branch, recreated on
+         * every commit) but unacceptable for `bit ci sync`, where the lane is the *authored* artifact and
+         * the branch is its mirror — deleting it would destroy the very thing being synced. When set, the
+         * stale-lane case throws instead, which the sync executor surfaces as a halt for a human.
+         */
+        noDestructiveRecovery?: boolean;
     }): Promise<string | undefined>;
     /**
      * Post-export cleanup: restore the workspace to the original lane / main so an interactive

package/dist/ci.main.runtime.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.CiMain = void 0;
+function _harmony() {
+  const data = require("@teambit/harmony");
+  _harmony = function () {
+    return data;
+  };
+  return data;
+}
 function _cli() {
   const data = require("@teambit/cli");
   _cli = function () {
@@ -144,6 +151,13 @@ function _merge() {
   };
   return data;
 }
+function _sync() {
+  const data = require("./commands/sync.cmd");
+  _sync = function () {
+    return data;
+  };
+  return data;
+}
 function _git() {
   const data = require("./git");
   _git = function () {
@@ -214,12 +228,45 @@ function _pullRequestRef() {
   };
   return data;
 }
+function _syncOrchestrator() {
+  const data = require("./sync/sync-orchestrator");
+  _syncOrchestrator = function () {
+    return data;
+  };
+  return data;
+}
+function _githubClient() {
+  const data = require("./sync/github-client");
+  _githubClient = function () {
+    return data;
+  };
+  return data;
+}
+function _gitOps() {
+  const data = require("./sync/git-ops");
+  _gitOps = function () {
+    return data;
+  };
+  return data;
+}
+function _syncConfig() {
+  const data = require("./sync/sync-config");
+  _syncConfig = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Registered git hosts (GitHub ships built-in; others register from their own aspect).
+ * @see GitHostProvider
+ */
+
 // Two distinct conflicts can surface from the remote on a concurrent `bit ci pr` race.
 // LANE_HASH_MISMATCH fires when both runners called `Lane.create` (the lane didn't exist on
 // the remote yet), so they each minted a random `sha1(v4())` hash — `sources.mergeLane` then
@@ -232,7 +279,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 const LANE_HASH_MISMATCH_MARKER = 'a lane with the same id already exists with a different hash';
 const COMPONENT_DIVERGENCE_MARKER = 'merge error occurred when exporting';
 class CiMain {
-  constructor(workspace, builder, status, lanes, snapping, exporter, importer, checkout, logger, config) {
+  constructor(workspace, builder, status, lanes, snapping, exporter, importer, checkout, logger, config, gitHostProviderSlot) {
     this.workspace = workspace;
     this.builder = builder;
     this.status = status;
@@ -243,15 +290,35 @@ class CiMain {
     this.checkout = checkout;
     this.logger = logger;
     this.config = config;
+    this.gitHostProviderSlot = gitHostProviderSlot;
   }
-  static async provider([cli, workspace, loggerAspect, builder, status, lanes, snapping, exporter, importer, checkout], config) {
+  static async provider([cli, workspace, loggerAspect, builder, status, lanes, snapping, exporter, importer, checkout], config, [gitHostProviderSlot]) {
     const logger = loggerAspect.createLogger(_ci().CiAspect.id);
-    const ci = new CiMain(workspace, builder, status, lanes, snapping, exporter, importer, checkout, logger, config);
+    const ci = new CiMain(workspace, builder, status, lanes, snapping, exporter, importer, checkout, logger, config, gitHostProviderSlot);
+    // GitHub ships built-in but is not privileged: registered through the same public slot any other
+    // host aspect uses. Credentials resolve lazily, so registering at aspect load is always safe.
+    ci.registerGitHostProvider(new (_githubClient().GitHubHostProvider)(message => logger.consoleWarning(message)));
     const ciCmd = new (_ci2().CiCmd)(workspace, logger);
-    ciCmd.commands = [new (_verify().CiVerifyCmd)(workspace, logger, ci), new (_pr().CiPrCmd)(workspace, logger, ci), new (_merge().CiMergeCmd)(workspace, logger, ci)];
+    ciCmd.commands = [new (_verify().CiVerifyCmd)(workspace, logger, ci), new (_pr().CiPrCmd)(workspace, logger, ci), new (_merge().CiMergeCmd)(workspace, logger, ci), new (_sync().CiSyncCmd)(workspace, logger, ci)];
     cli.register(ciCmd);
     return ci;
   }
+
+  /**
+   * Register a git host (GitHub, GitLab, …) that `bit ci sync` can use for its pull-request
+   * operations. Exactly one provider is selected per run, by the `origin` remote (see
+   * `selectGitHostProvider`); registering a provider never changes how a repository claimed by a
+   * different provider is handled.
+   */
+  registerGitHostProvider(provider) {
+    this.gitHostProviderSlot.register(provider);
+    return this;
+  }
+
+  /** Every registered git host provider, in registration order (one provider per registration). */
+  listGitHostProviders() {
+    return this.gitHostProviderSlot.values();
+  }
   async getBranchName() {
     try {
       // if we are running on github, use the GITHUB_HEAD_REF env var
@@ -315,28 +382,43 @@ class CiMain {
    * @example convertBranchToLaneId("feature/New-Component") => "my-scope/feature-new-component"
    */
   convertBranchToLaneId(branchName) {
-    // Sanitize branch name to make it valid for Bit lane IDs by replacing slashes and dots with dashes
-    // and converting to lowercase
     const sanitizedBranch = branchName.replace(/[/.]/g, '-').toLowerCase();
     return `${this.workspace.defaultScope}/${sanitizedBranch}`;
   }
+
+  /**
+   * The repository's default branch name, whole — slashes included (see `parseOriginHeadRef`).
+   * Local `origin/HEAD` symref first, then the remote's own answer, then the conventional probe.
+   */
   async getDefaultBranchName() {
     try {
-      // Try to get the default branch from git symbolic-ref
       const result = await _git().git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
-      const defaultBranch = result.trim().split('/').pop();
-      return defaultBranch || 'master';
-    } catch (e) {
-      // Fallback to common default branch names
-      try {
-        const branches = await _git().git.branch(['-r']);
-        if (branches.all.includes('origin/main')) return 'main';
-        if (branches.all.includes('origin/master')) return 'master';
-        return 'master'; // Final fallback
-      } catch {
-        this.logger.console(_chalk().default.yellow(`Unable to detect default branch, using 'master': ${e.toString()}`));
-        return 'master';
-      }
+      const local = (0, _gitOps().parseOriginHeadRef)(result);
+      // Every candidate is validated before it is returned: this value becomes a checkout target and a
+      // push refspec, and an option-like name ("-x") would be read by git as a flag. An unusable answer
+      // falls through to the next source rather than reaching the argv.
+      if (local && (0, _syncConfig().isValidGitBranchName)(local)) return local;
+    } catch {
+      // no local origin/HEAD — normal in a fresh CI clone; ask the remote itself below.
+    }
+    const remote = await (0, _gitOps().remoteHeadBranch)();
+    if (remote && (0, _syncConfig().isValidGitBranchName)(remote)) return remote;
+    return this.probeDefaultBranchName();
+  }
+
+  /**
+   * Last-resort fallback: the two conventional names among the remote branches, then `master`.
+   * Deliberately only `main`/`master` — any wider guess risks protecting the wrong branch.
+   */
+  async probeDefaultBranchName(originalError) {
+    try {
+      const branches = await _git().git.branch(['-r']);
+      if (branches.all.includes('origin/main')) return 'main';
+      if (branches.all.includes('origin/master')) return 'master';
+      return 'master';
+    } catch {
+      this.logger.console(_chalk().default.yellow(`Unable to detect default branch, using 'master'${originalError ? `: ${originalError}` : ''}`));
+      return 'master';
     }
   }
   async getGitCommitMessage() {
@@ -474,6 +556,36 @@ class CiMain {
     return undefined;
   }
 
+  /**
+   * Public entry point onto `switchToLane` for the lane-sync executor; returns the error instead of
+   * throwing. `switchToLane` spreads caller options AFTER its defaults, so `forceOurs: true` is
+   * overridable — the sync import direction depends on that. Do not reorder that spread.
+   */
+  async switchToLaneForSync(laneName, options = {}) {
+    return this.switchToLane(laneName, options);
+  }
+
+  /**
+   * Re-read `.bitmap` from disk into the live workspace. `bit ci sync` moves the git checkout
+   * underneath a running process, and until the reload every bit operation resolves against the
+   * `.bitmap` loaded at startup — and the next write would persist that stale state.
+   */
+  async reloadWorkspaceFromDisk() {
+    await this.workspace._reloadConsumer();
+  }
+
+  /** `bit ci sync` — reconcile Bit lanes and the main scope with git branches and PRs (see `SyncOrchestrator`). */
+  async sync(opts = {}) {
+    return new (_syncOrchestrator().SyncOrchestrator)({
+      ci: this,
+      workspace: this.workspace,
+      logger: this.logger,
+      lanes: this.lanes,
+      checkout: this.checkout,
+      config: this.config
+    }).sync(opts);
+  }
+
   /**
    * Sync *config-only* changes from main onto the lane — without a full `bit lane merge`.
    *
@@ -729,7 +841,8 @@ class CiMain {
     dryRun,
     keepLane,
     skipCleanup,
-    skipTasks
+    skipTasks,
+    noDestructiveRecovery
   }) {
     // The post-export cleanup switches the workspace back to main, which re-checks-out main's HEAD
     // and re-imports every workspace component — pointless when the workspace is about to be
@@ -778,7 +891,8 @@ class CiMain {
         build,
         dryRun,
         skipCleanup: resolvedSkipCleanup,
-        skipTasks: resolvedSkipTasks
+        skipTasks: resolvedSkipTasks,
+        noDestructiveRecovery
       });
     }
     return this.snapAndExportWithTempLane({
@@ -850,7 +964,8 @@ class CiMain {
     build,
     dryRun,
     skipCleanup,
-    skipTasks
+    skipTasks,
+    noDestructiveRecovery
   }) {
     // Query the remote (by name, to avoid fetching all lanes) so we know whether to reuse or create
     const existingLanes = await this.lanes.getLanes({
@@ -903,6 +1018,14 @@ class CiMain {
           if (!isStaleLane) {
             throw new Error(`Failed to switch to remote lane ${laneId.toString()}: ${errMsg || '(no error captured)'}. ` + `Refusing destructive recovery for this failure class — the error doesn't match the ` + `stale-lane marker, so deleting the lane could destroy real history. Investigate or retry.`);
           }
+          if (noDestructiveRecovery) {
+            // `bit ci sync` mirrors an authored lane onto a branch. Recovering by deleting the remote
+            // lane and re-forking it from main would discard the lane's components and history — the
+            // exact artifact the sync exists to preserve — and the next sync would then happily
+            // mirror the now-empty lane onto the branch. Fail loudly instead; the executor turns this
+            // into a halt so a human resolves the lane on bit.cloud.
+            throw new Error(`Failed to switch to remote lane ${laneId.toString()}: ${errMsg || '(no error captured)'}. ` + `The stale-lane recovery (delete the remote lane and recreate it from main) is disabled ` + `for this caller, because the lane is an authored artifact rather than a throwaway PR ` + `lane. Resolve the lane on bit.cloud and re-run.`);
+          }
           this.logger.console(_chalk().default.yellow(`Stale remote lane ${laneId.toString()} — switching failed. ` + `Deleting it and creating a fresh lane to recover.`));
           // Re-check the remote lane's hash immediately before deleting. The central-hub delete
           // API is name-based — there's no compare-and-swap — so two CI jobs racing the same
@@ -1512,7 +1635,11 @@ class CiMain {
 
     // Stage everything: `bit checkout head` earlier in the flow may modify files
     // beyond .bitmap and pnpm-lock.yaml, so a narrow `git add` would miss them.
-    await _git().git.add(['.']);
+    // The two exclusions in the shared helper keep the local bit scope (`.bit`) and `node_modules` out
+    // of the commit in a workspace whose `.gitignore` lacks Bit's block — otherwise this stages the
+    // object store into the default branch. Same helper the sync executors use, so all three commit
+    // paths agree on what counts as workspace content.
+    await (0, _gitOps().addAllExceptScopeAndModules)();
     const commitMessage = await this.getCustomCommitMessage();
     await _git().git.commit(commitMessage);
     const statusAfterCommit = await _git().git.status();
@@ -1705,7 +1832,7 @@ class CiMain {
 exports.CiMain = CiMain;
 _defineProperty(CiMain, "runtime", _cli().MainRuntime);
 _defineProperty(CiMain, "dependencies", [_cli().CLIAspect, _workspace().WorkspaceAspect, _logger().LoggerAspect, _builder().BuilderAspect, _status().StatusAspect, _lanes().LanesAspect, _snapping().SnappingAspect, _export().ExportAspect, _importer().ImporterAspect, _checkout().CheckoutAspect]);
-_defineProperty(CiMain, "slots", []);
+_defineProperty(CiMain, "slots", [_harmony().Slot.withType()]);
 function reportToString(result) {
   return typeof result === 'string' ? result : result.data;
 }