@teambit/ci 1.0.485 → 1.0.486

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

@@ -0,0 +1,171 @@
+/**
+ * Git primitives shared by the lane and main sync executors; each encodes a decision that must stay
+ * identical on both paths.
+ */
+/** paths the sync executors never treat as workspace content — see `cleanUntrackedScoped` */
+export declare const SYNC_EXCLUDED_PATHS: string[];
+/**
+ * How a raw git invocation is run, injectable so a helper whose whole content is its argv can be unit
+ * tested without a repository. Production always uses {@link realGitRaw}.
+ */
+export type GitArgsRunner = (args: string[]) => Promise<unknown>;
+export declare const realGitRaw: GitArgsRunner;
+/**
+ * Remove untracked files, leaving the local bit scope and installed packages alone. No `-x` (ignored
+ * files stay), and `.bit` / `node_modules` are excluded explicitly — without that, the clean deletes
+ * the local scope in a workspace whose `.gitignore` lacks Bit's block.
+ */
+export declare function cleanUntrackedScoped(run?: GitArgsRunner): Promise<void>;
+/**
+ * Refuse a branch name git would read as an option or reject as a ref. Not every branch reaching the
+ * checkout comes from validated config: the default branch is derived from the remote
+ * (`getDefaultBranchName`), so the primitive that builds the argv is where the guard belongs — every
+ * caller inherits it.
+ */
+export declare function assertCheckoutableBranch(branch: string): void;
+/**
+ * Put the working tree on `branch` holding nothing but that commit's content, then make the workspace
+ * re-read the checked-out `.bitmap`. Order matters: `checkout -f` (leftover tracked changes must not
+ * abort the target), then the scoped clean (a forced checkout leaves untracked files in place, and
+ * every commit path stages with `-A`), then the reload so it reads the pristine tree. With
+ * `startPoint`, `-B` creates-or-resets the branch — refused when the local branch holds commits no
+ * remote contains, because moving it would orphan unpushed work; the predicate is remote containment,
+ * not start-point ancestry (a fully pushed tip loses nothing in either legitimate reset shape).
+ */
+export declare function checkoutPristine(branch: string, startPoint: string | undefined, reload: () => Promise<void>, run?: GitArgsRunner): Promise<void>;
+/**
+ * Whether the branch exists locally. Judged by output, never by whether the call threw: simple-git's
+ * `raw` resolves with empty output on some non-zero exits instead of rejecting.
+ */
+export declare function localBranchExists(branch: string, run?: GitArgsRunner): Promise<boolean>;
+/**
+ * `checkoutPristine` for the restore paths: a start point only when the branch is absent locally
+ * (detached-HEAD/single-branch checkouts) — passing `origin/<branch>` when it exists would `-B`-reset
+ * the developer's default branch and discard their unpushed commits.
+ */
+export declare function checkoutPristineRestore(branch: string, reload: () => Promise<void>, run?: GitArgsRunner): Promise<void>;
+/**
+ * Stage every change except `.bit` / `node_modules` (a bare `add -A` would commit the local scope when
+ * `.gitignore` lacks Bit's block). The `:(exclude)` pathspecs make git skip those trees instead of
+ * staging them for a reset to undo; `git add` refuses them when a named path IS ignored — the case where
+ * the traversal is already cheap — so the add-then-reset pair is the fallback. Both leave the same index,
+ * and `git reset -- <paths>` is a no-op for paths absent from it, so neither fallback command can fail.
+ */
+export declare function addAllExceptScopeAndModules(run?: GitArgsRunner): Promise<void>;
+/**
+ * Whether a `git status` path is one the sync executors never treat as workspace content. Applied
+ * everywhere a status is interpreted — otherwise `.bit`/`node_modules` files count as drift when
+ * `.gitignore` lacks Bit's block.
+ */
+export declare function isNonContentPath(path: string): boolean;
+/**
+ * The refspec every sync fetch passes **explicitly**, overriding whatever `remote.origin.fetch` this
+ * checkout was configured with.
+ */
+export declare const ALL_HEADS_REFSPEC = "+refs/heads/*:refs/remotes/origin/*";
+/**
+ * Fetch `origin` so every branch it has is available as `refs/remotes/origin/<branch>`. A bare fetch
+ * honours the checkout's configured `remote.origin.fetch`, which in a single-branch clone updates
+ * exactly one ref while enumeration (`ls-remote`) sees every branch; an explicit refspec overrides the
+ * config. Does not make shallow clones work — depth is a different axis.
+ */
+export declare function fetchRemoteHeads(run?: GitArgsRunner): Promise<void>;
+/** Refspec that updates exactly one remote-tracking ref — a mid-run re-read of a single branch. */
+export declare function singleHeadRefspec(branch: string): string;
+/**
+ * `origin/<branch>`'s tip as the remote has it NOW: every other ref a run reads comes from one fetch at
+ * its start. Undefined when the branch is gone or unreadable — never a stale sha, because the answer
+ * decides whether a branch deletion is still safe.
+ */
+export declare function refetchBranchTip(branch: string, run?: GitArgsRunner): Promise<string | undefined>;
+/**
+ * `git push` argv that deletes a remote branch only while its tip is still `expectedTipSha`. Full
+ * `:refs/heads/<b>` refspec so the branch name can never be read as an option; the lease makes the server
+ * itself refuse a racing update rather than lose it.
+ */
+export declare function deleteBranchArgs(branch: string, expectedTipSha: string): string[];
+/**
+ * Whether a failed push was the lease refusing. The wording varies by git version and transport:
+ * "stale info" (client-side check), "is at X but expected Y" (receive-pack), and "incorrect old value
+ * provided" (the local/file transport, which is what CI's e2e remotes use). Over-matching is the safe
+ * direction — the only consequence is reporting a branch as kept rather than as a failed delete.
+ */
+export declare function isStaleLeaseRejection(message: string): boolean;
+/** Whether `origin` has the given branch. Assumes a `git fetch` isn't required (uses `ls-remote`). */
+export declare function branchExistsOnRemote(branch: string): Promise<boolean>;
+/**
+ * Every branch `origin` has, by short name. `ls-remote` rather than `git branch -r` so the answer
+ * cannot be narrowed by the checkout's refspec or staleness.
+ */
+export declare function listRemoteBranches(): Promise<string[]>;
+/**
+ * Is `maybeAncestor` reachable from `descendant` (true for identical commits)? Not `merge-base
+ * --is-ancestor`: it answers via the exit code, and simple-git's `raw` resolves on exit 1, so "not an
+ * ancestor" would read as yes. Throws when the commits share no history or a revision cannot resolve.
+ */
+export declare function isAncestor(maybeAncestor: string, descendant: string): Promise<boolean>;
+/** The prefix `git symbolic-ref refs/remotes/origin/HEAD` puts in front of the default branch name. */
+export declare const ORIGIN_HEAD_REF_PREFIX = "refs/remotes/origin/";
+/**
+ * The default branch name out of `git symbolic-ref refs/remotes/origin/HEAD` output, or undefined for
+ * an unrecognised shape. Strips the prefix; never splits on `/` — branch names may contain slashes
+ * (`release/main`), and truncating would protect the wrong branch.
+ */
+export declare function parseOriginHeadRef(symbolicRefOutput: string): string | undefined;
+/**
+ * The default branch name out of `git ls-remote --symref origin HEAD` output, or undefined when no
+ * symref line is present (some servers omit it). Same slash discipline as {@link parseOriginHeadRef}.
+ */
+export declare function parseLsRemoteSymref(lsRemoteOutput: string): string | undefined;
+/**
+ * The remote's own answer for its default branch. Unlike the local `origin/HEAD` symref or enumerating
+ * `origin/*`, this cannot be stale or narrowed — only unanswered (undefined hands on to the fallback).
+ */
+export declare function remoteHeadBranch(run?: GitArgsRunner): Promise<string | undefined>;
+/**
+ * The git repository's root, or undefined outside a repo. A bit workspace is not necessarily the repo
+ * root, and GitHub only discovers workflows at `<repo>/.github/workflows`.
+ */
+export declare function gitRepoRoot(): Promise<string | undefined>;
+/**
+ * Reading `git config`, injectable so the identity decision can be unit tested without a repository.
+ * There is deliberately no writer — see {@link resolveGitIdentity}.
+ */
+export type GitConfigIO = {
+    /** the configured value, or undefined when unset (or when git cannot answer) */
+    get(key: string): Promise<string | undefined>;
+};
+export declare const realGitConfigIO: GitConfigIO;
+/**
+ * The identity the sync commits with when nothing else says otherwise. A contract: the scaffolded
+ * workflow templates (`init-scaffold.ts`) and the GitHub Action's defaults must carry the same pair,
+ * or the same repository commits under different authors depending on entry point.
+ */
+export declare const DEFAULT_GIT_USER_NAME = "bit-sync[bot]";
+export declare const DEFAULT_GIT_USER_EMAIL = "bit-sync[bot]@users.noreply.github.com";
+export type GitIdentity = {
+    name: string;
+    email: string;
+};
+/**
+ * Who the sync commits as. Read-only on purpose: writing these keys into the repository's config
+ * would outlive the run and re-author the developer's own later commits as the bot. Precedence per
+ * key: configured git identity > `GIT_USER_NAME`/`GIT_USER_EMAIL` > default.
+ */
+export declare function resolveGitIdentity(io?: GitConfigIO, env?: NodeJS.ProcessEnv): Promise<GitIdentity>;
+/** The `git -c` pair that applies an identity to ONE invocation, leaving the repo's config alone. */
+export declare function identityArgs(identity: GitIdentity): string[];
+export type IdentityDeps = {
+    run?: GitArgsRunner;
+    io?: GitConfigIO;
+    env?: NodeJS.ProcessEnv;
+};
+/**
+ * Run a git command that may author a commit. Every such command needs the identity — a fresh CI
+ * checkout has none, and git refuses to commit ("Please tell me who you are") without one.
+ */
+export declare function gitWithIdentity(args: string[], deps?: IdentityDeps): Promise<string>;
+/** `git commit` under the sync identity; `extraArgs` carries flags such as `--allow-empty`. */
+export declare function commitWithIdentity(message: string, opts?: IdentityDeps & {
+    extraArgs?: string[];
+}): Promise<void>;

package/dist/sync/git-ops.js

@@ -0,0 +1,354 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYNC_EXCLUDED_PATHS = exports.ORIGIN_HEAD_REF_PREFIX = exports.DEFAULT_GIT_USER_NAME = exports.DEFAULT_GIT_USER_EMAIL = exports.ALL_HEADS_REFSPEC = void 0;
+exports.addAllExceptScopeAndModules = addAllExceptScopeAndModules;
+exports.assertCheckoutableBranch = assertCheckoutableBranch;
+exports.branchExistsOnRemote = branchExistsOnRemote;
+exports.checkoutPristine = checkoutPristine;
+exports.checkoutPristineRestore = checkoutPristineRestore;
+exports.cleanUntrackedScoped = cleanUntrackedScoped;
+exports.commitWithIdentity = commitWithIdentity;
+exports.deleteBranchArgs = deleteBranchArgs;
+exports.fetchRemoteHeads = fetchRemoteHeads;
+exports.gitRepoRoot = gitRepoRoot;
+exports.gitWithIdentity = gitWithIdentity;
+exports.identityArgs = identityArgs;
+exports.isAncestor = isAncestor;
+exports.isNonContentPath = isNonContentPath;
+exports.isStaleLeaseRejection = isStaleLeaseRejection;
+exports.listRemoteBranches = listRemoteBranches;
+exports.localBranchExists = localBranchExists;
+exports.parseLsRemoteSymref = parseLsRemoteSymref;
+exports.parseOriginHeadRef = parseOriginHeadRef;
+exports.realGitRaw = exports.realGitConfigIO = void 0;
+exports.refetchBranchTip = refetchBranchTip;
+exports.remoteHeadBranch = remoteHeadBranch;
+exports.resolveGitIdentity = resolveGitIdentity;
+exports.singleHeadRefspec = singleHeadRefspec;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _git() {
+  const data = require("../git");
+  _git = function () {
+    return data;
+  };
+  return data;
+}
+function _syncConfig() {
+  const data = require("./sync-config");
+  _syncConfig = function () {
+    return data;
+  };
+  return data;
+}
+const _excluded = ["extraArgs"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+/**
+ * Git primitives shared by the lane and main sync executors; each encodes a decision that must stay
+ * identical on both paths.
+ */
+
+/** paths the sync executors never treat as workspace content — see `cleanUntrackedScoped` */
+const SYNC_EXCLUDED_PATHS = exports.SYNC_EXCLUDED_PATHS = ['.bit', 'node_modules'];
+
+/**
+ * How a raw git invocation is run, injectable so a helper whose whole content is its argv can be unit
+ * tested without a repository. Production always uses {@link realGitRaw}.
+ */
+
+const realGitRaw = args => _git().git.raw(args);
+
+/**
+ * Remove untracked files, leaving the local bit scope and installed packages alone. No `-x` (ignored
+ * files stay), and `.bit` / `node_modules` are excluded explicitly — without that, the clean deletes
+ * the local scope in a workspace whose `.gitignore` lacks Bit's block.
+ */
+exports.realGitRaw = realGitRaw;
+async function cleanUntrackedScoped(run = realGitRaw) {
+  await run(['clean', '-fd', ...SYNC_EXCLUDED_PATHS.flatMap(path => ['-e', path])]);
+}
+
+/**
+ * Refuse a branch name git would read as an option or reject as a ref. Not every branch reaching the
+ * checkout comes from validated config: the default branch is derived from the remote
+ * (`getDefaultBranchName`), so the primitive that builds the argv is where the guard belongs — every
+ * caller inherits it.
+ */
+function assertCheckoutableBranch(branch) {
+  const problem = (0, _syncConfig().validateBranchName)(branch);
+  if (problem) {
+    throw new (_bitError().BitError)(`bit ci sync cannot check out "${branch}": ${problem}. Rename the branch, or set the intended name ` + `explicitly in the "teambit.git/ci" sync config.`);
+  }
+}
+
+/**
+ * Put the working tree on `branch` holding nothing but that commit's content, then make the workspace
+ * re-read the checked-out `.bitmap`. Order matters: `checkout -f` (leftover tracked changes must not
+ * abort the target), then the scoped clean (a forced checkout leaves untracked files in place, and
+ * every commit path stages with `-A`), then the reload so it reads the pristine tree. With
+ * `startPoint`, `-B` creates-or-resets the branch — refused when the local branch holds commits no
+ * remote contains, because moving it would orphan unpushed work; the predicate is remote containment,
+ * not start-point ancestry (a fully pushed tip loses nothing in either legitimate reset shape).
+ */
+async function checkoutPristine(branch, startPoint, reload, run = realGitRaw) {
+  assertCheckoutableBranch(branch);
+  if (startPoint && (await localBranchExists(branch, run))) {
+    const containedIn = String((await run(['branch', '-r', '--contains', `refs/heads/${branch}`])) ?? '').trim();
+    if (!containedIn) {
+      throw new Error(`local branch "${branch}" has commits that no remote branch contains — resetting it would ` + `orphan them (recoverable only from the reflog). Push or back up the local branch, delete ` + `it, or run from a clean checkout`);
+    }
+  }
+  await run(startPoint ? ['checkout', '-f', '-B', branch, startPoint] : ['checkout', '-f', branch]);
+  await cleanUntrackedScoped(run);
+  await reload();
+}
+
+/**
+ * Whether the branch exists locally. Judged by output, never by whether the call threw: simple-git's
+ * `raw` resolves with empty output on some non-zero exits instead of rejecting.
+ */
+async function localBranchExists(branch, run = realGitRaw) {
+  const out = await run(['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]).catch(() => '');
+  return String(out ?? '').trim().length > 0;
+}
+
+/**
+ * `checkoutPristine` for the restore paths: a start point only when the branch is absent locally
+ * (detached-HEAD/single-branch checkouts) — passing `origin/<branch>` when it exists would `-B`-reset
+ * the developer's default branch and discard their unpushed commits.
+ */
+async function checkoutPristineRestore(branch, reload, run = realGitRaw) {
+  const startPoint = (await localBranchExists(branch, run)) ? undefined : `origin/${branch}`;
+  await checkoutPristine(branch, startPoint, reload, run);
+}
+
+/**
+ * Stage every change except `.bit` / `node_modules` (a bare `add -A` would commit the local scope when
+ * `.gitignore` lacks Bit's block). The `:(exclude)` pathspecs make git skip those trees instead of
+ * staging them for a reset to undo; `git add` refuses them when a named path IS ignored — the case where
+ * the traversal is already cheap — so the add-then-reset pair is the fallback. Both leave the same index,
+ * and `git reset -- <paths>` is a no-op for paths absent from it, so neither fallback command can fail.
+ */
+async function addAllExceptScopeAndModules(run = realGitRaw) {
+  const stageAll = ['add', '-A', '--', '.'];
+  try {
+    await run([...stageAll, ...SYNC_EXCLUDED_PATHS.map(path => `:(exclude)${path}`)]);
+  } catch {
+    await run(stageAll);
+    await run(['reset', '-q', '--', ...SYNC_EXCLUDED_PATHS]);
+  }
+}
+
+/**
+ * Whether a `git status` path is one the sync executors never treat as workspace content. Applied
+ * everywhere a status is interpreted — otherwise `.bit`/`node_modules` files count as drift when
+ * `.gitignore` lacks Bit's block.
+ */
+function isNonContentPath(path) {
+  return SYNC_EXCLUDED_PATHS.some(excluded => path === excluded || path.startsWith(`${excluded}/`));
+}
+
+/**
+ * The refspec every sync fetch passes **explicitly**, overriding whatever `remote.origin.fetch` this
+ * checkout was configured with.
+ */
+const ALL_HEADS_REFSPEC = exports.ALL_HEADS_REFSPEC = '+refs/heads/*:refs/remotes/origin/*';
+
+/**
+ * Fetch `origin` so every branch it has is available as `refs/remotes/origin/<branch>`. A bare fetch
+ * honours the checkout's configured `remote.origin.fetch`, which in a single-branch clone updates
+ * exactly one ref while enumeration (`ls-remote`) sees every branch; an explicit refspec overrides the
+ * config. Does not make shallow clones work — depth is a different axis.
+ */
+async function fetchRemoteHeads(run = realGitRaw) {
+  await run(['fetch', 'origin', ALL_HEADS_REFSPEC]);
+}
+
+/** Refspec that updates exactly one remote-tracking ref — a mid-run re-read of a single branch. */
+function singleHeadRefspec(branch) {
+  return `+refs/heads/${branch}:refs/remotes/origin/${branch}`;
+}
+
+/**
+ * `origin/<branch>`'s tip as the remote has it NOW: every other ref a run reads comes from one fetch at
+ * its start. Undefined when the branch is gone or unreadable — never a stale sha, because the answer
+ * decides whether a branch deletion is still safe.
+ */
+async function refetchBranchTip(branch, run = realGitRaw) {
+  try {
+    await run(['fetch', 'origin', singleHeadRefspec(branch)]);
+    const out = await run(['rev-parse', `refs/remotes/origin/${branch}`]);
+    return String(out ?? '').trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * `git push` argv that deletes a remote branch only while its tip is still `expectedTipSha`. Full
+ * `:refs/heads/<b>` refspec so the branch name can never be read as an option; the lease makes the server
+ * itself refuse a racing update rather than lose it.
+ */
+function deleteBranchArgs(branch, expectedTipSha) {
+  return ['origin', `--force-with-lease=refs/heads/${branch}:${expectedTipSha}`, `:refs/heads/${branch}`];
+}
+
+/**
+ * Whether a failed push was the lease refusing. The wording varies by git version and transport:
+ * "stale info" (client-side check), "is at X but expected Y" (receive-pack), and "incorrect old value
+ * provided" (the local/file transport, which is what CI's e2e remotes use). Over-matching is the safe
+ * direction — the only consequence is reporting a branch as kept rather than as a failed delete.
+ */
+function isStaleLeaseRejection(message) {
+  return /stale info|force-with-lease|but expected|incorrect old value/i.test(message);
+}
+
+/** Whether `origin` has the given branch. Assumes a `git fetch` isn't required (uses `ls-remote`). */
+async function branchExistsOnRemote(branch) {
+  const out = await _git().git.raw(['ls-remote', '--heads', 'origin', branch]);
+  return out.trim().length > 0;
+}
+
+/**
+ * Every branch `origin` has, by short name. `ls-remote` rather than `git branch -r` so the answer
+ * cannot be narrowed by the checkout's refspec or staleness.
+ */
+async function listRemoteBranches() {
+  const out = await _git().git.raw(['ls-remote', '--heads', 'origin']);
+  const prefix = 'refs/heads/';
+  return out.split('\n').map(line => line.split('\t')[1]?.trim()).filter(ref => Boolean(ref && ref.startsWith(prefix))).map(ref => ref.slice(prefix.length));
+}
+
+/**
+ * Is `maybeAncestor` reachable from `descendant` (true for identical commits)? Not `merge-base
+ * --is-ancestor`: it answers via the exit code, and simple-git's `raw` resolves on exit 1, so "not an
+ * ancestor" would read as yes. Throws when the commits share no history or a revision cannot resolve.
+ */
+async function isAncestor(maybeAncestor, descendant) {
+  const ancestorSha = (await _git().git.revparse([maybeAncestor])).trim();
+  const mergeBase = (await _git().git.raw(['merge-base', maybeAncestor, descendant])).trim();
+  if (!ancestorSha || !mergeBase) throw new Error(`could not compare ${maybeAncestor} against ${descendant}`);
+  return ancestorSha === mergeBase;
+}
+
+/** The prefix `git symbolic-ref refs/remotes/origin/HEAD` puts in front of the default branch name. */
+const ORIGIN_HEAD_REF_PREFIX = exports.ORIGIN_HEAD_REF_PREFIX = 'refs/remotes/origin/';
+
+/**
+ * The default branch name out of `git symbolic-ref refs/remotes/origin/HEAD` output, or undefined for
+ * an unrecognised shape. Strips the prefix; never splits on `/` — branch names may contain slashes
+ * (`release/main`), and truncating would protect the wrong branch.
+ */
+function parseOriginHeadRef(symbolicRefOutput) {
+  const ref = symbolicRefOutput.trim();
+  if (!ref.startsWith(ORIGIN_HEAD_REF_PREFIX)) return undefined;
+  return ref.slice(ORIGIN_HEAD_REF_PREFIX.length) || undefined;
+}
+
+/** The prefix a symref answer from `git ls-remote --symref origin HEAD` puts before the branch name. */
+const LS_REMOTE_SYMREF_PREFIX = 'ref: refs/heads/';
+
+/**
+ * The default branch name out of `git ls-remote --symref origin HEAD` output, or undefined when no
+ * symref line is present (some servers omit it). Same slash discipline as {@link parseOriginHeadRef}.
+ */
+function parseLsRemoteSymref(lsRemoteOutput) {
+  const line = lsRemoteOutput.split('\n').find(l => l.startsWith(LS_REMOTE_SYMREF_PREFIX));
+  if (!line) return undefined;
+  const name = line.slice(LS_REMOTE_SYMREF_PREFIX.length).split('\t')[0].trim();
+  return name || undefined;
+}
+
+/**
+ * The remote's own answer for its default branch. Unlike the local `origin/HEAD` symref or enumerating
+ * `origin/*`, this cannot be stale or narrowed — only unanswered (undefined hands on to the fallback).
+ */
+async function remoteHeadBranch(run = realGitRaw) {
+  try {
+    const out = await run(['ls-remote', '--symref', 'origin', 'HEAD']);
+    return parseLsRemoteSymref(String(out ?? ''));
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The git repository's root, or undefined outside a repo. A bit workspace is not necessarily the repo
+ * root, and GitHub only discovers workflows at `<repo>/.github/workflows`.
+ */
+async function gitRepoRoot() {
+  try {
+    const root = (await _git().git.raw(['rev-parse', '--show-toplevel'])).trim();
+    return root || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Reading `git config`, injectable so the identity decision can be unit tested without a repository.
+ * There is deliberately no writer — see {@link resolveGitIdentity}.
+ */
+
+const realGitConfigIO = exports.realGitConfigIO = {
+  get: key => _git().git.raw(['config', '--get', key]).then(out => out.trim().length ? out.trim() : undefined)
+  // A missing key and "not a git repository" both exit non-zero; both mean "no identity to keep".
+  .catch(() => undefined)
+};
+
+/**
+ * The identity the sync commits with when nothing else says otherwise. A contract: the scaffolded
+ * workflow templates (`init-scaffold.ts`) and the GitHub Action's defaults must carry the same pair,
+ * or the same repository commits under different authors depending on entry point.
+ */
+const DEFAULT_GIT_USER_NAME = exports.DEFAULT_GIT_USER_NAME = 'bit-sync[bot]';
+const DEFAULT_GIT_USER_EMAIL = exports.DEFAULT_GIT_USER_EMAIL = 'bit-sync[bot]@users.noreply.github.com';
+/**
+ * Who the sync commits as. Read-only on purpose: writing these keys into the repository's config
+ * would outlive the run and re-author the developer's own later commits as the bot. Precedence per
+ * key: configured git identity > `GIT_USER_NAME`/`GIT_USER_EMAIL` > default.
+ */
+async function resolveGitIdentity(io = realGitConfigIO, env = process.env) {
+  return {
+    name: (await io.get('user.name')) || env.GIT_USER_NAME || DEFAULT_GIT_USER_NAME,
+    email: (await io.get('user.email')) || env.GIT_USER_EMAIL || DEFAULT_GIT_USER_EMAIL
+  };
+}
+
+/** The `git -c` pair that applies an identity to ONE invocation, leaving the repo's config alone. */
+function identityArgs(identity) {
+  return ['-c', `user.name=${identity.name}`, '-c', `user.email=${identity.email}`];
+}
+/**
+ * Run a git command that may author a commit. Every such command needs the identity — a fresh CI
+ * checkout has none, and git refuses to commit ("Please tell me who you are") without one.
+ */
+async function gitWithIdentity(args, deps = {}) {
+  const {
+    run = realGitRaw,
+    io = realGitConfigIO,
+    env = process.env
+  } = deps;
+  const identity = await resolveGitIdentity(io, env);
+  return String((await run([...identityArgs(identity), ...args])) ?? '');
+}
+
+/** `git commit` under the sync identity; `extraArgs` carries flags such as `--allow-empty`. */
+async function commitWithIdentity(message, opts = {}) {
+  const {
+      extraArgs = []
+    } = opts,
+    deps = _objectWithoutProperties(opts, _excluded);
+  await gitWithIdentity(['commit', '-m', message, ...extraArgs], deps);
+}
+
+//# sourceMappingURL=git-ops.js.map

package/dist/sync/git-ops.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_bitError","data","require","_git","_syncConfig","_excluded","_objectWithoutProperties","e","t","o","r","i","_objectWithoutPropertiesLoose","Object","getOwnPropertySymbols","n","length","indexOf","propertyIsEnumerable","call","hasOwnProperty","SYNC_EXCLUDED_PATHS","exports","realGitRaw","args","git","raw","cleanUntrackedScoped","run","flatMap","path","assertCheckoutableBranch","branch","problem","validateBranchName","BitError","checkoutPristine","startPoint","reload","localBranchExists","containedIn","String","trim","Error","out","catch","checkoutPristineRestore","undefined","addAllExceptScopeAndModules","stageAll","map","isNonContentPath","some","excluded","startsWith","ALL_HEADS_REFSPEC","fetchRemoteHeads","singleHeadRefspec","refetchBranchTip","deleteBranchArgs","expectedTipSha","isStaleLeaseRejection","message","test","branchExistsOnRemote","listRemoteBranches","prefix","split","line","filter","ref","Boolean","slice","isAncestor","maybeAncestor","descendant","ancestorSha","revparse","mergeBase","ORIGIN_HEAD_REF_PREFIX","parseOriginHeadRef","symbolicRefOutput","LS_REMOTE_SYMREF_PREFIX","parseLsRemoteSymref","lsRemoteOutput","find","l","name","remoteHeadBranch","gitRepoRoot","root","realGitConfigIO","get","key","then","DEFAULT_GIT_USER_NAME","DEFAULT_GIT_USER_EMAIL","resolveGitIdentity","io","env","process","GIT_USER_NAME","email","GIT_USER_EMAIL","identityArgs","identity","gitWithIdentity","deps","commitWithIdentity","opts","extraArgs"],"sources":["git-ops.ts"],"sourcesContent":["import { BitError } from '@teambit/bit-error';\nimport { git } from '../git';\nimport { validateBranchName } from './sync-config';\n\n/**\n * Git primitives shared by the lane and main sync executors; each encodes a decision that must stay\n * identical on both paths.\n */\n\n/** paths the sync executors never treat as workspace content — see `cleanUntrackedScoped` */\nexport const SYNC_EXCLUDED_PATHS = ['.bit', 'node_modules'];\n\n/**\n * How a raw git invocation is run, injectable so a helper whose whole content is its argv can be unit\n * tested without a repository. Production always uses {@link realGitRaw}.\n */\nexport type GitArgsRunner = (args: string[]) => Promise<unknown>;\n\nexport const realGitRaw: GitArgsRunner = (args) => git.raw(args);\n\n/**\n * Remove untracked files, leaving the local bit scope and installed packages alone. No `-x` (ignored\n * files stay), and `.bit` / `node_modules` are excluded explicitly — without that, the clean deletes\n * the local scope in a workspace whose `.gitignore` lacks Bit's block.\n */\nexport async function cleanUntrackedScoped(run: GitArgsRunner = realGitRaw): Promise<void> {\n  await run(['clean', '-fd', ...SYNC_EXCLUDED_PATHS.flatMap((path) => ['-e', path])]);\n}\n\n/**\n * Refuse a branch name git would read as an option or reject as a ref. Not every branch reaching the\n * checkout comes from validated config: the default branch is derived from the remote\n * (`getDefaultBranchName`), so the primitive that builds the argv is where the guard belongs — every\n * caller inherits it.\n */\nexport function assertCheckoutableBranch(branch: string): void {\n  const problem = validateBranchName(branch);\n  if (problem) {\n    throw new BitError(\n      `bit ci sync cannot check out \"${branch}\": ${problem}. Rename the branch, or set the intended name ` +\n        `explicitly in the \"teambit.git/ci\" sync config.`\n    );\n  }\n}\n\n/**\n * Put the working tree on `branch` holding nothing but that commit's content, then make the workspace\n * re-read the checked-out `.bitmap`. Order matters: `checkout -f` (leftover tracked changes must not\n * abort the target), then the scoped clean (a forced checkout leaves untracked files in place, and\n * every commit path stages with `-A`), then the reload so it reads the pristine tree. With\n * `startPoint`, `-B` creates-or-resets the branch — refused when the local branch holds commits no\n * remote contains, because moving it would orphan unpushed work; the predicate is remote containment,\n * not start-point ancestry (a fully pushed tip loses nothing in either legitimate reset shape).\n */\nexport async function checkoutPristine(\n  branch: string,\n  startPoint: string | undefined,\n  reload: () => Promise<void>,\n  run: GitArgsRunner = realGitRaw\n): Promise<void> {\n  assertCheckoutableBranch(branch);\n  if (startPoint && (await localBranchExists(branch, run))) {\n    const containedIn = String((await run(['branch', '-r', '--contains', `refs/heads/${branch}`])) ?? '').trim();\n    if (!containedIn) {\n      throw new Error(\n        `local branch \"${branch}\" has commits that no remote branch contains — resetting it would ` +\n          `orphan them (recoverable only from the reflog). Push or back up the local branch, delete ` +\n          `it, or run from a clean checkout`\n      );\n    }\n  }\n  await run(startPoint ? ['checkout', '-f', '-B', branch, startPoint] : ['checkout', '-f', branch]);\n  await cleanUntrackedScoped(run);\n  await reload();\n}\n\n/**\n * Whether the branch exists locally. Judged by output, never by whether the call threw: simple-git's\n * `raw` resolves with empty output on some non-zero exits instead of rejecting.\n */\nexport async function localBranchExists(branch: string, run: GitArgsRunner = realGitRaw): Promise<boolean> {\n  const out = await run(['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]).catch(() => '');\n  return String(out ?? '').trim().length > 0;\n}\n\n/**\n * `checkoutPristine` for the restore paths: a start point only when the branch is absent locally\n * (detached-HEAD/single-branch checkouts) — passing `origin/<branch>` when it exists would `-B`-reset\n * the developer's default branch and discard their unpushed commits.\n */\nexport async function checkoutPristineRestore(\n  branch: string,\n  reload: () => Promise<void>,\n  run: GitArgsRunner = realGitRaw\n): Promise<void> {\n  const startPoint = (await localBranchExists(branch, run)) ? undefined : `origin/${branch}`;\n  await checkoutPristine(branch, startPoint, reload, run);\n}\n\n/**\n * Stage every change except `.bit` / `node_modules` (a bare `add -A` would commit the local scope when\n * `.gitignore` lacks Bit's block). The `:(exclude)` pathspecs make git skip those trees instead of\n * staging them for a reset to undo; `git add` refuses them when a named path IS ignored — the case where\n * the traversal is already cheap — so the add-then-reset pair is the fallback. Both leave the same index,\n * and `git reset -- <paths>` is a no-op for paths absent from it, so neither fallback command can fail.\n */\nexport async function addAllExceptScopeAndModules(run: GitArgsRunner = realGitRaw): Promise<void> {\n  const stageAll = ['add', '-A', '--', '.'];\n  try {\n    await run([...stageAll, ...SYNC_EXCLUDED_PATHS.map((path) => `:(exclude)${path}`)]);\n  } catch {\n    await run(stageAll);\n    await run(['reset', '-q', '--', ...SYNC_EXCLUDED_PATHS]);\n  }\n}\n\n/**\n * Whether a `git status` path is one the sync executors never treat as workspace content. Applied\n * everywhere a status is interpreted — otherwise `.bit`/`node_modules` files count as drift when\n * `.gitignore` lacks Bit's block.\n */\nexport function isNonContentPath(path: string): boolean {\n  return SYNC_EXCLUDED_PATHS.some((excluded) => path === excluded || path.startsWith(`${excluded}/`));\n}\n\n/**\n * The refspec every sync fetch passes **explicitly**, overriding whatever `remote.origin.fetch` this\n * checkout was configured with.\n */\nexport const ALL_HEADS_REFSPEC = '+refs/heads/*:refs/remotes/origin/*';\n\n/**\n * Fetch `origin` so every branch it has is available as `refs/remotes/origin/<branch>`. A bare fetch\n * honours the checkout's configured `remote.origin.fetch`, which in a single-branch clone updates\n * exactly one ref while enumeration (`ls-remote`) sees every branch; an explicit refspec overrides the\n * config. Does not make shallow clones work — depth is a different axis.\n */\nexport async function fetchRemoteHeads(run: GitArgsRunner = realGitRaw): Promise<void> {\n  await run(['fetch', 'origin', ALL_HEADS_REFSPEC]);\n}\n\n/** Refspec that updates exactly one remote-tracking ref — a mid-run re-read of a single branch. */\nexport function singleHeadRefspec(branch: string): string {\n  return `+refs/heads/${branch}:refs/remotes/origin/${branch}`;\n}\n\n/**\n * `origin/<branch>`'s tip as the remote has it NOW: every other ref a run reads comes from one fetch at\n * its start. Undefined when the branch is gone or unreadable — never a stale sha, because the answer\n * decides whether a branch deletion is still safe.\n */\nexport async function refetchBranchTip(branch: string, run: GitArgsRunner = realGitRaw): Promise<string | undefined> {\n  try {\n    await run(['fetch', 'origin', singleHeadRefspec(branch)]);\n    const out = await run(['rev-parse', `refs/remotes/origin/${branch}`]);\n    return String(out ?? '').trim() || undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * `git push` argv that deletes a remote branch only while its tip is still `expectedTipSha`. Full\n * `:refs/heads/<b>` refspec so the branch name can never be read as an option; the lease makes the server\n * itself refuse a racing update rather than lose it.\n */\nexport function deleteBranchArgs(branch: string, expectedTipSha: string): string[] {\n  return ['origin', `--force-with-lease=refs/heads/${branch}:${expectedTipSha}`, `:refs/heads/${branch}`];\n}\n\n/**\n * Whether a failed push was the lease refusing. The wording varies by git version and transport:\n * \"stale info\" (client-side check), \"is at X but expected Y\" (receive-pack), and \"incorrect old value\n * provided\" (the local/file transport, which is what CI's e2e remotes use). Over-matching is the safe\n * direction — the only consequence is reporting a branch as kept rather than as a failed delete.\n */\nexport function isStaleLeaseRejection(message: string): boolean {\n  return /stale info|force-with-lease|but expected|incorrect old value/i.test(message);\n}\n\n/** Whether `origin` has the given branch. Assumes a `git fetch` isn't required (uses `ls-remote`). */\nexport async function branchExistsOnRemote(branch: string): Promise<boolean> {\n  const out = await git.raw(['ls-remote', '--heads', 'origin', branch]);\n  return out.trim().length > 0;\n}\n\n/**\n * Every branch `origin` has, by short name. `ls-remote` rather than `git branch -r` so the answer\n * cannot be narrowed by the checkout's refspec or staleness.\n */\nexport async function listRemoteBranches(): Promise<string[]> {\n  const out = await git.raw(['ls-remote', '--heads', 'origin']);\n  const prefix = 'refs/heads/';\n  return out\n    .split('\\n')\n    .map((line) => line.split('\\t')[1]?.trim())\n    .filter((ref): ref is string => Boolean(ref && ref.startsWith(prefix)))\n    .map((ref) => ref.slice(prefix.length));\n}\n\n/**\n * Is `maybeAncestor` reachable from `descendant` (true for identical commits)? Not `merge-base\n * --is-ancestor`: it answers via the exit code, and simple-git's `raw` resolves on exit 1, so \"not an\n * ancestor\" would read as yes. Throws when the commits share no history or a revision cannot resolve.\n */\nexport async function isAncestor(maybeAncestor: string, descendant: string): Promise<boolean> {\n  const ancestorSha = (await git.revparse([maybeAncestor])).trim();\n  const mergeBase = (await git.raw(['merge-base', maybeAncestor, descendant])).trim();\n  if (!ancestorSha || !mergeBase) throw new Error(`could not compare ${maybeAncestor} against ${descendant}`);\n  return ancestorSha === mergeBase;\n}\n\n/** The prefix `git symbolic-ref refs/remotes/origin/HEAD` puts in front of the default branch name. */\nexport const ORIGIN_HEAD_REF_PREFIX = 'refs/remotes/origin/';\n\n/**\n * The default branch name out of `git symbolic-ref refs/remotes/origin/HEAD` output, or undefined for\n * an unrecognised shape. Strips the prefix; never splits on `/` — branch names may contain slashes\n * (`release/main`), and truncating would protect the wrong branch.\n */\nexport function parseOriginHeadRef(symbolicRefOutput: string): string | undefined {\n  const ref = symbolicRefOutput.trim();\n  if (!ref.startsWith(ORIGIN_HEAD_REF_PREFIX)) return undefined;\n  return ref.slice(ORIGIN_HEAD_REF_PREFIX.length) || undefined;\n}\n\n/** The prefix a symref answer from `git ls-remote --symref origin HEAD` puts before the branch name. */\nconst LS_REMOTE_SYMREF_PREFIX = 'ref: refs/heads/';\n\n/**\n * The default branch name out of `git ls-remote --symref origin HEAD` output, or undefined when no\n * symref line is present (some servers omit it). Same slash discipline as {@link parseOriginHeadRef}.\n */\nexport function parseLsRemoteSymref(lsRemoteOutput: string): string | undefined {\n  const line = lsRemoteOutput.split('\\n').find((l) => l.startsWith(LS_REMOTE_SYMREF_PREFIX));\n  if (!line) return undefined;\n  const name = line.slice(LS_REMOTE_SYMREF_PREFIX.length).split('\\t')[0].trim();\n  return name || undefined;\n}\n\n/**\n * The remote's own answer for its default branch. Unlike the local `origin/HEAD` symref or enumerating\n * `origin/*`, this cannot be stale or narrowed — only unanswered (undefined hands on to the fallback).\n */\nexport async function remoteHeadBranch(run: GitArgsRunner = realGitRaw): Promise<string | undefined> {\n  try {\n    const out = await run(['ls-remote', '--symref', 'origin', 'HEAD']);\n    return parseLsRemoteSymref(String(out ?? ''));\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * The git repository's root, or undefined outside a repo. A bit workspace is not necessarily the repo\n * root, and GitHub only discovers workflows at `<repo>/.github/workflows`.\n */\nexport async function gitRepoRoot(): Promise<string | undefined> {\n  try {\n    const root = (await git.raw(['rev-parse', '--show-toplevel'])).trim();\n    return root || undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Reading `git config`, injectable so the identity decision can be unit tested without a repository.\n * There is deliberately no writer — see {@link resolveGitIdentity}.\n */\nexport type GitConfigIO = {\n  /** the configured value, or undefined when unset (or when git cannot answer) */\n  get(key: string): Promise<string | undefined>;\n};\n\nexport const realGitConfigIO: GitConfigIO = {\n  get: (key) =>\n    git\n      .raw(['config', '--get', key])\n      .then((out) => (out.trim().length ? out.trim() : undefined))\n      // A missing key and \"not a git repository\" both exit non-zero; both mean \"no identity to keep\".\n      .catch(() => undefined),\n};\n\n/**\n * The identity the sync commits with when nothing else says otherwise. A contract: the scaffolded\n * workflow templates (`init-scaffold.ts`) and the GitHub Action's defaults must carry the same pair,\n * or the same repository commits under different authors depending on entry point.\n */\nexport const DEFAULT_GIT_USER_NAME = 'bit-sync[bot]';\nexport const DEFAULT_GIT_USER_EMAIL = 'bit-sync[bot]@users.noreply.github.com';\n\nexport type GitIdentity = { name: string; email: string };\n\n/**\n * Who the sync commits as. Read-only on purpose: writing these keys into the repository's config\n * would outlive the run and re-author the developer's own later commits as the bot. Precedence per\n * key: configured git identity > `GIT_USER_NAME`/`GIT_USER_EMAIL` > default.\n */\nexport async function resolveGitIdentity(\n  io: GitConfigIO = realGitConfigIO,\n  env: NodeJS.ProcessEnv = process.env\n): Promise<GitIdentity> {\n  return {\n    name: (await io.get('user.name')) || env.GIT_USER_NAME || DEFAULT_GIT_USER_NAME,\n    email: (await io.get('user.email')) || env.GIT_USER_EMAIL || DEFAULT_GIT_USER_EMAIL,\n  };\n}\n\n/** The `git -c` pair that applies an identity to ONE invocation, leaving the repo's config alone. */\nexport function identityArgs(identity: GitIdentity): string[] {\n  return ['-c', `user.name=${identity.name}`, '-c', `user.email=${identity.email}`];\n}\n\nexport type IdentityDeps = { run?: GitArgsRunner; io?: GitConfigIO; env?: NodeJS.ProcessEnv };\n\n/**\n * Run a git command that may author a commit. Every such command needs the identity — a fresh CI\n * checkout has none, and git refuses to commit (\"Please tell me who you are\") without one.\n */\nexport async function gitWithIdentity(args: string[], deps: IdentityDeps = {}): Promise<string> {\n  const { run = realGitRaw, io = realGitConfigIO, env = process.env } = deps;\n  const identity = await resolveGitIdentity(io, env);\n  return String((await run([...identityArgs(identity), ...args])) ?? '');\n}\n\n/** `git commit` under the sync identity; `extraArgs` carries flags such as `--allow-empty`. */\nexport async function commitWithIdentity(\n  message: string,\n  opts: IdentityDeps & { extraArgs?: string[] } = {}\n): Promise<void> {\n  const { extraArgs = [], ...deps } = opts;\n  await gitWithIdentity(['commit', '-m', message, ...extraArgs], deps);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/sync/git-ops.spec.d.ts

@@ -0,0 +1 @@
+export {};