clever-tools 4.5.2 → 4.6.0

package/src/models/git-isomorphic.js

@@ -0,0 +1,153 @@
+import * as git from 'isomorphic-git';
+import _ from 'lodash';
+import fs from 'node:fs';
+import { config } from '../config/config.js';
+import { slugify } from '../lib/slugify.js';
+import { Git } from './git.js';
+import * as http from './isomorphic-http-with-agent.js';
+
+export class GitIsomorphic extends Git {
+  constructor() {
+    super('isomorphic');
+  }
+
+  async #getRepo() {
+    const dir = await this._getRepoDir();
+    return { fs, dir, http };
+  }
+
+  #onAuth() {
+    return {
+      username: config.token,
+      password: config.secret,
+    };
+  }
+
+  async addRemote(remoteName, url) {
+    this._debug('addRemote', remoteName, url);
+    const repo = await this.#getRepo();
+    const safeRemoteName = slugify(remoteName);
+    const allRemotes = await git.listRemotes({ ...repo });
+    const existingRemote = _.find(allRemotes, { remote: safeRemoteName });
+    if (existingRemote == null) {
+      // In some situations, we may end up with race conditions so we force it
+      return git.addRemote({ ...repo, remote: safeRemoteName, url, force: true });
+    }
+  }
+
+  async resolveFullCommitId(commitId) {
+    this._debug('resolveFullCommitId', commitId);
+    if (commitId == null) {
+      return null;
+    }
+    try {
+      const repo = await this.#getRepo();
+      return await git.expandOid({ ...repo, oid: commitId });
+    } catch (e) {
+      if (e.code === 'ShortOidNotFound') {
+        throw new Error(`Commit id ${commitId} is ambiguous`);
+      }
+      throw e;
+    }
+  }
+
+  async getRemoteCommit(remoteUrl) {
+    this._debug('getRemoteCommit', remoteUrl);
+    const repo = await this.#getRepo();
+    const remoteInfos = await git.getRemoteInfo({
+      ...repo,
+      onAuth: this.#onAuth,
+      url: remoteUrl,
+    });
+    return _.get(remoteInfos, 'refs.heads.master');
+  }
+
+  async getFullBranch(branchName) {
+    this._debug('getFullBranch', branchName);
+    const repo = await this.#getRepo();
+    if (branchName === '') {
+      const currentBranch = await git.currentBranch({ ...repo, fullname: true });
+      return currentBranch || 'HEAD';
+    }
+    return git.expandRef({ ...repo, ref: branchName });
+  }
+
+  async getBranchCommit(refspec) {
+    this._debug('getBranchCommit', refspec);
+    const repo = await this.#getRepo();
+    const oid = await git.resolveRef({ ...repo, ref: refspec });
+    // When a refspec refers to an annotated tag, the OID ref represents the annotation and not the commit directly,
+    // that's why we need a call to `readCommit`.
+    const res = await git.readCommit({ ...repo, ref: refspec, oid });
+    return res.oid;
+  }
+
+  async isExistingTag(tag) {
+    this._debug('isExistingTag', tag);
+    const repo = await this.#getRepo();
+    const tags = await git.listTags({
+      ...repo,
+    });
+    return tags.includes(tag);
+  }
+
+  async push(remoteUrl, branchRefspec, force, remoteName) {
+    const refspec = `${branchRefspec}:refs/heads/master`;
+    this._debug('push', remoteUrl, refspec, force ? '--force' : '');
+    const repo = await this.#getRepo();
+    try {
+      const push = await git.push({
+        ...repo,
+        onAuth: this.#onAuth,
+        url: remoteUrl,
+        ref: branchRefspec,
+        remoteRef: 'master',
+        remote: remoteName,
+        force,
+      });
+      if (push.errors != null) {
+        throw new Error(push.errors.join(', '));
+      }
+      return push;
+    } catch (e) {
+      if (e.code === 'PushRejectedNonFastForward') {
+        throw new Error('Push rejected because it was not a simple fast-forward, use --force to override');
+      }
+      throw e;
+    }
+  }
+
+  async completeBranches() {
+    this._debug('completeBranches');
+    return this.#getRepo().then((repo) => git.listBranches(repo));
+  }
+
+  /**
+   * Check if the current directory is a git repository
+   * @returns {Promise<boolean>}
+   */
+  async isInsideGitRepo() {
+    this._debug('isInsideGitRepo');
+    return this.#getRepo()
+      .then(() => true)
+      .catch(() => false);
+  }
+
+  /**
+   * Check if the current git working directory is clean
+   * @returns {Promise<boolean>}
+   */
+  async isGitWorkingDirectoryClean() {
+    this._debug('isGitWorkingDirectoryClean');
+    const repo = await this.#getRepo();
+    const status = await git.statusMatrix({ ...repo });
+    const isStatusEmpty =
+      status.filter(([filepath, head, workdir]) => {
+        // WARNING: isomorphic-git does not support global gitignore so we filter hidden files and dirs to reduce the amount of false positives
+        const isHidden = filepath.startsWith('.');
+        const isCleverJson = filepath === '.clever.json';
+        return (!isHidden || isCleverJson) && head !== workdir;
+      }).length === 0;
+    return isStatusEmpty;
+  }
+}

package/src/models/git-system.js

@@ -0,0 +1,182 @@
+import { simpleGit } from 'simple-git';
+import { config } from '../config/config.js';
+import { slugify } from '../lib/slugify.js';
+import { Git } from './git.js';
+
+export class GitSystem extends Git {
+  #gitAvailabilityChecked = false;
+
+  constructor() {
+    super('system');
+  }
+
+  async addRemote(remoteName, url) {
+    this._debug('addRemote', remoteName, url);
+    const git = await this.#getSimpleGit();
+    const safeRemoteName = slugify(remoteName);
+    const remotes = await git.getRemotes();
+    const existingRemote = remotes.find((r) => r.name === safeRemoteName);
+    if (existingRemote == null) {
+      await git.addRemote(safeRemoteName, url);
+    }
+  }
+
+  async #getSimpleGit() {
+    await this.#checkGitAvailability();
+    const dir = await this._getRepoDir();
+    return simpleGit(dir);
+  }
+
+  async #checkGitAvailability() {
+    if (this.#gitAvailabilityChecked) {
+      return;
+    }
+    const git = simpleGit();
+    const ver = await git.version();
+    if (!ver.installed) {
+      throw new GitNotFoundError();
+    }
+    this.#gitAvailabilityChecked = true;
+  }
+
+  async resolveFullCommitId(commitId) {
+    this._debug('resolveFullCommitId', commitId);
+    if (commitId == null) {
+      return null;
+    }
+    const git = await this.#getSimpleGit();
+    try {
+      const fullOid = await git.revparse([commitId]);
+      return fullOid.trim();
+    } catch (e) {
+      if (e.message.includes('unknown revision') || e.message.includes('ambiguous argument')) {
+        throw new Error(`Commit id ${commitId} is ambiguous`);
+      }
+      throw e;
+    }
+  }
+
+  async getRemoteCommit(remoteUrl) {
+    const git = await this.#getSimpleGit();
+    const authUrl = this.#buildAuthenticatedUrl(remoteUrl);
+    this._debug('getRemoteCommit', this.#redactUrl(authUrl));
+    try {
+      const result = await git.listRemote(['--refs', authUrl.toString()]);
+      // Parse output: "<sha>\trefs/heads/master"
+      const lines = result.trim().split('\n');
+      for (const line of lines) {
+        const [sha, ref] = line.split('\t');
+        if (ref === 'refs/heads/master') {
+          return sha;
+        }
+      }
+      return undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  #buildAuthenticatedUrl(url) {
+    const urlObj = new URL(url);
+    urlObj.username = config.token;
+    urlObj.password = config.secret;
+    return urlObj;
+  }
+
+  async getFullBranch(branchName) {
+    this._debug('getFullBranch', branchName);
+    const git = await this.#getSimpleGit();
+    if (branchName === '') {
+      const branch = await git.branch();
+      if (branch.current) {
+        return `refs/heads/${branch.current}`;
+      }
+      return 'HEAD';
+    }
+    // Try to expand the ref
+    try {
+      const fullRef = await git.revparse(['--symbolic-full-name', branchName]);
+      return fullRef.trim();
+    } catch {
+      // If it fails, it might be a commit hash, return as-is
+      return branchName;
+    }
+  }
+
+  async getBranchCommit(refspec) {
+    this._debug('getBranchCommit', refspec);
+    const git = await this.#getSimpleGit();
+    // Use rev-parse with ^{commit} to dereference tags to their commit
+    const oid = await git.revparse([`${refspec}^{commit}`]);
+    return oid.trim();
+  }
+
+  async isExistingTag(tag) {
+    this._debug('isExistingTag', tag);
+    const git = await this.#getSimpleGit();
+    const tags = await git.tags();
+    return tags.all.includes(tag);
+  }
+
+  #redactUrl(url) {
+    const urlObj = typeof url === 'string' ? new URL(url) : url;
+    const redacted = new URL(urlObj.toString());
+    if (redacted.username) redacted.username = '***';
+    if (redacted.password) redacted.password = '***';
+    return redacted.toString();
+  }
+
+  async push(remoteUrl, branchRefspec, force) {
+    const git = await this.#getSimpleGit();
+    const authUrl = this.#buildAuthenticatedUrl(remoteUrl);
+    const refspec = `${branchRefspec}:refs/heads/master`;
+    this._debug('push', this.#redactUrl(authUrl), refspec, force ? '--force' : '');
+    const options = ['--porcelain'];
+    if (force) {
+      options.push('--force');
+    }
+    try {
+      await git.push(authUrl.toString(), refspec, options);
+      return {};
+    } catch (e) {
+      if (e.message.includes('non-fast-forward') || e.message.includes('[rejected]')) {
+        throw new Error('Push rejected because it was not a simple fast-forward, use --force to override');
+      }
+      throw e;
+    }
+  }
+
+  async completeBranches() {
+    this._debug('completeBranches');
+    const git = await this.#getSimpleGit();
+    const branches = await git.branchLocal();
+    return branches.all;
+  }
+
+  async isInsideGitRepo() {
+    this._debug('isInsideGitRepo');
+    try {
+      await this._getRepoDir();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async isGitWorkingDirectoryClean() {
+    this._debug('isGitWorkingDirectoryClean');
+    const git = await this.#getSimpleGit();
+    const status = await git.status();
+    return status.isClean();
+  }
+}
+
+class GitNotFoundError extends Error {
+  constructor() {
+    super(
+      'The system git feature requires git to be installed and available in your PATH\n' +
+        'Either install git or disable this feature with: clever features disable system-git',
+    );
+    this.name = 'GitNotFoundError';
+  }
+}

package/src/models/git.js

@@ -1,151 +1,173 @@
-import * as git from 'isomorphic-git';
-import _ from 'lodash';
 import fs from 'node:fs';
 import path from 'node:path';
-import { slugify } from '../lib/slugify.js';
-import { loadOAuthConf } from './configuration.js';
+
+import { isFeatureEnabled } from '../config/features.js';
+import { Logger } from '../logger.js';
 import { findPath } from './fs-utils.js';
-import * as http from './isomorphic-http-with-agent.js';
-
-async function getRepo() {
-  try {
-    const dir = await findPath('.', '.git');
-    return { fs, dir, http };
-  } catch {
-    throw new Error('Could not find the .git folder.');
-  }
-}
 
-async function onAuth() {
-  const tokens = await loadOAuthConf();
-  return {
-    username: tokens.token,
-    password: tokens.secret,
-  };
-}
+/**
+ * Abstract base class for git operations.
+ * Implementations: GitIsomorphic (JS-based) and GitSystem (system git command)
+ */
+export class Git {
+  /** @type {Git | null} */
+  static #instance = null;
+
+  /** @type {string} */
+  #name;
 
-export async function addRemote(remoteName, url) {
-  const repo = await getRepo();
-  const safeRemoteName = slugify(remoteName);
-  const allRemotes = await git.listRemotes({ ...repo });
-  const existingRemote = _.find(allRemotes, { remote: safeRemoteName });
-  if (existingRemote == null) {
-    // In some situations, we may end up with race conditions so we force it
-    return git.addRemote({ ...repo, remote: safeRemoteName, url, force: true });
+  /**
+   * @param {string} name - Backend name for logging purposes
+   */
+  constructor(name) {
+    this.#name = name;
   }
-}
 
-export async function resolveFullCommitId(commitId) {
-  if (commitId == null) {
-    return null;
+  /**
+   * Get the git implementation based on the feature flag.
+   * Returns a cached instance if available.
+   * @returns {Promise<Git>}
+   */
+  static async get() {
+    if (Git.#instance == null) {
+      const useSystemGit = await isFeatureEnabled('system-git');
+      if (useSystemGit) {
+        const { GitSystem } = await import('./git-system.js');
+        Git.#instance = new GitSystem();
+      } else {
+        const { GitIsomorphic } = await import('./git-isomorphic.js');
+        Git.#instance = new GitIsomorphic();
+      }
+    }
+    return Git.#instance;
   }
-  try {
-    const repo = await getRepo();
-    return await git.expandOid({ ...repo, oid: commitId });
-  } catch (e) {
-    if (e.code === 'ShortOidNotFound') {
-      throw new Error(`Commit id ${commitId} is ambiguous`);
+
+  /**
+   * Log a debug message for git operations
+   * @protected
+   * @param {string} operation - The operation name
+   * @param {...string} args - Additional arguments to log
+   */
+  _debug(operation, ...args) {
+    const argsStr = args.length > 0 ? ` ${args.join(' ')}` : '';
+    Logger.debug(`git(${this.#name}): ${operation}${argsStr}`);
+  }
+
+  /**
+   * Get the repository directory
+   * @protected
+   * @returns {Promise<string>}
+   */
+  async _getRepoDir() {
+    try {
+      return await findPath('.', '.git');
+    } catch {
+      throw new Error('Could not find the .git folder');
     }
-    throw e;
   }
-}
 
-export async function getRemoteCommit(remoteUrl) {
-  const repo = await getRepo();
-  const remoteInfos = await git.getRemoteInfo({
-    ...repo,
-    onAuth,
-    url: remoteUrl,
-  });
-  return _.get(remoteInfos, 'refs.heads.master');
-}
+  /**
+   * Add a remote to the repository
+   * @param {string} remoteName
+   * @param {string} url
+   * @returns {Promise<void>}
+   */
+  async addRemote(remoteName, url) {
+    throw new Error('Not implemented');
+  }
 
-export async function getFullBranch(branchName) {
-  const repo = await getRepo();
-  if (branchName === '') {
-    const currentBranch = await git.currentBranch({ ...repo, fullname: true });
-    return currentBranch || 'HEAD';
+  /**
+   * Resolve a short commit ID to its full form
+   * @param {string | null} commitId
+   * @returns {Promise<string | null>}
+   */
+  async resolveFullCommitId(commitId) {
+    throw new Error('Not implemented');
   }
-  return git.expandRef({ ...repo, ref: branchName });
-}
 
-export async function getBranchCommit(refspec) {
-  const repo = await getRepo();
-  const oid = await git.resolveRef({ ...repo, ref: refspec });
-  // When a refspec refers to an annotated tag, the OID ref represents the annotation and not the commit directly,
-  // that's why we need a call to `readCommit`.
-  const res = await git.readCommit({ ...repo, ref: refspec, oid });
-  return res.oid;
-}
+  /**
+   * Get the commit SHA of the master branch on a remote
+   * @param {string} remoteUrl
+   * @returns {Promise<string | undefined>}
+   */
+  async getRemoteCommit(remoteUrl) {
+    throw new Error('Not implemented');
+  }
 
-export async function isExistingTag(tag) {
-  const repo = await getRepo();
-  const tags = await git.listTags({
-    ...repo,
-  });
-  return tags.includes(tag);
-}
+  /**
+   * Get the full ref name for a branch
+   * @param {string} branchName - Branch name, or empty string for current branch
+   * @returns {Promise<string>}
+   */
+  async getFullBranch(branchName) {
+    throw new Error('Not implemented');
+  }
 
-export async function push(remoteUrl, branchRefspec, force) {
-  const repo = await getRepo();
-  try {
-    const push = await git.push({
-      ...repo,
-      onAuth,
-      url: remoteUrl,
-      ref: branchRefspec,
-      remoteRef: 'master',
-      force,
-    });
-    if (push.errors != null) {
-      throw new Error(push.errors.join(', '));
-    }
-    return push;
-  } catch (e) {
-    if (e.code === 'PushRejectedNonFastForward') {
-      throw new Error('Push rejected because it was not a simple fast-forward. Use "--force" to override.');
-    }
-    throw e;
+  /**
+   * Get the commit SHA for a branch or tag
+   * @param {string} refspec
+   * @returns {Promise<string>}
+   */
+  async getBranchCommit(refspec) {
+    throw new Error('Not implemented');
   }
-}
 
-export function completeBranches() {
-  return getRepo().then((repo) => git.listBranches(repo));
-}
+  /**
+   * Check if a tag exists
+   * @param {string} tag
+   * @returns {Promise<boolean>}
+   */
+  async isExistingTag(tag) {
+    throw new Error('Not implemented');
+  }
 
-export async function isShallow() {
-  const { dir } = await getRepo();
-  try {
-    await fs.promises.access(path.join(dir, '.git', 'shallow'));
-    return true;
-  } catch {
-    return false;
+  /**
+   * Push to a remote repository
+   * @param {string} remoteUrl
+   * @param {string} branchRefspec
+   * @param {boolean} force
+   * @returns {Promise<object>}
+   */
+  async push(remoteUrl, branchRefspec, force) {
+    throw new Error('Not implemented');
   }
-}
 
-/**
- * Check if the current directory is a git repository
- * @returns {Promise<boolean>}
- */
-export async function isInsideGitRepo() {
-  return getRepo()
-    .then(() => true)
-    .catch(() => false);
-}
+  /**
+   * List local branches (for autocompletion)
+   * @returns {Promise<string[]>}
+   */
+  async completeBranches() {
+    throw new Error('Not implemented');
+  }
 
-/**
- * Check if the current git working directory is clean
- * @returns {Promise<boolean>}
- */
-export async function isGitWorkingDirectoryClean() {
-  const repo = await getRepo();
-  const status = await git.statusMatrix({ ...repo });
-  const isStatusEmpty =
-    status.filter(([filepath, head, workdir]) => {
-      // WARNING: isomorphic-git does not support global gitignore so we filter hidden files and dirs to reduce the amount of false positives
-      const isHidden = filepath.startsWith('.');
-      const isCleverJson = filepath === '.clever.json';
-      return (!isHidden || isCleverJson) && head !== workdir;
-    }).length === 0;
-  return isStatusEmpty;
+  /**
+   * Check if the repository is a shallow clone
+   * @returns {Promise<boolean>}
+   */
+  async isShallow() {
+    this._debug('isShallow');
+    const dir = await this._getRepoDir();
+    try {
+      await fs.promises.access(path.join(dir, '.git', 'shallow'));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if the current directory is inside a git repository
+   * @returns {Promise<boolean>}
+   */
+  async isInsideGitRepo() {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Check if the git working directory is clean (no uncommitted changes)
+   * @returns {Promise<boolean>}
+   */
+  async isGitWorkingDirectoryClean() {
+    throw new Error('Not implemented');
+  }
 }

package/src/models/ids-resolver.js

@@ -1,7 +1,7 @@
 import { getSummary } from '@clevercloud/client/esm/api/v2/user.js';
+import { loadIdsCache, writeIdsCache } from '../config/cache.js';
 import { Logger } from '../logger.js';
 import * as User from '../models/user.js';
-import { loadIdsCache, writeIdsCache } from './configuration.js';
 import * as Organisation from './organisation.js';
 import { sendToApi } from './send-to-api.js';