plugin-git-manager 1.0.3

package/dist/node_modules/simple-git/node_modules/debug/src/node.js

@@ -0,0 +1,263 @@
+/**
+ * Module dependencies.
+ */
+
+const tty = require('tty');
+const util = require('util');
+
+/**
+ * This is the Node.js implementation of `debug()`.
+ */
+
+exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.destroy = util.deprecate(
+	() => {},
+	'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+);
+
+/**
+ * Colors.
+ */
+
+exports.colors = [6, 2, 3, 4, 5, 1];
+
+try {
+	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+	// eslint-disable-next-line import/no-extraneous-dependencies
+	const supportsColor = require('supports-color');
+
+	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+		exports.colors = [
+			20,
+			21,
+			26,
+			27,
+			32,
+			33,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			56,
+			57,
+			62,
+			63,
+			68,
+			69,
+			74,
+			75,
+			76,
+			77,
+			78,
+			79,
+			80,
+			81,
+			92,
+			93,
+			98,
+			99,
+			112,
+			113,
+			128,
+			129,
+			134,
+			135,
+			148,
+			149,
+			160,
+			161,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			171,
+			172,
+			173,
+			178,
+			179,
+			184,
+			185,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			203,
+			204,
+			205,
+			206,
+			207,
+			208,
+			209,
+			214,
+			215,
+			220,
+			221
+		];
+	}
+} catch (error) {
+	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+}
+
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
+
+exports.inspectOpts = Object.keys(process.env).filter(key => {
+	return /^debug_/i.test(key);
+}).reduce((obj, key) => {
+	// Camel-case
+	const prop = key
+		.substring(6)
+		.toLowerCase()
+		.replace(/_([a-z])/g, (_, k) => {
+			return k.toUpperCase();
+		});
+
+	// Coerce string value into JS value
+	let val = process.env[key];
+	if (/^(yes|on|true|enabled)$/i.test(val)) {
+		val = true;
+	} else if (/^(no|off|false|disabled)$/i.test(val)) {
+		val = false;
+	} else if (val === 'null') {
+		val = null;
+	} else {
+		val = Number(val);
+	}
+
+	obj[prop] = val;
+	return obj;
+}, {});
+
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+function useColors() {
+	return 'colors' in exports.inspectOpts ?
+		Boolean(exports.inspectOpts.colors) :
+		tty.isatty(process.stderr.fd);
+}
+
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+	const {namespace: name, useColors} = this;
+
+	if (useColors) {
+		const c = this.color;
+		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+	} else {
+		args[0] = getDate() + name + ' ' + args[0];
+	}
+}
+
+function getDate() {
+	if (exports.inspectOpts.hideDate) {
+		return '';
+	}
+	return new Date().toISOString() + ' ';
+}
+
+/**
+ * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
+ */
+
+function log(...args) {
+	return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+	if (namespaces) {
+		process.env.DEBUG = namespaces;
+	} else {
+		// If you set a process.env field to null or undefined, it gets cast to the
+		// string 'null' or 'undefined'. Just delete instead.
+		delete process.env.DEBUG;
+	}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+	return process.env.DEBUG;
+}
+
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
+
+function init(debug) {
+	debug.inspectOpts = {};
+
+	const keys = Object.keys(exports.inspectOpts);
+	for (let i = 0; i < keys.length; i++) {
+		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+	}
+}
+
+module.exports = require('./common')(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
+
+formatters.o = function (v) {
+	this.inspectOpts.colors = this.useColors;
+	return util.inspect(v, this.inspectOpts)
+		.split('\n')
+		.map(str => str.trim())
+		.join(' ');
+};
+
+/**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */
+
+formatters.O = function (v) {
+	this.inspectOpts.colors = this.useColors;
+	return util.inspect(v, this.inspectOpts);
+};

package/dist/node_modules/simple-git/package.json

@@ -0,0 +1 @@
+{"name":"simple-git","description":"Simple GIT interface for node.js","version":"3.36.0","author":"Steve King <steve@mydev.co>","contributors":[{"name":"Steve King","email":"steve@mydev.co"}],"funding":{"type":"github","url":"https://github.com/steveukx/git-js?sponsor=1"},"keywords":["git","source control","vcs"],"license":"MIT","repository":{"type":"git","url":"https://github.com/steveukx/git-js.git","directory":"simple-git"},"main":"dist/cjs/index.js","module":"dist/esm/index.js","exports":{".":{"types":"./dist/typings/index.d.ts","import":"./dist/esm/index.js","require":"./dist/cjs/index.js"},"./promise":{"require":"./promise.js"}},"types":"./dist/typings/index.d.ts","files":["promise.*","dist"],"dependencies":{"@kwsites/file-exists":"^1.1.1","@kwsites/promise-deferred":"^1.1.1","@simple-git/args-pathspec":"^1.0.3","@simple-git/argv-parser":"^1.1.0","debug":"^4.4.0"},"_lastModified":"2026-04-25T07:57:51.194Z"}

package/dist/node_modules/simple-git/promise.js

@@ -0,0 +1,17 @@
+console.error(`=============================================
+simple-git has supported promises / async await since version 2.6.0.
+ Importing from 'simple-git/promise' has been deprecated and will
+ report this error until the next major release of version 4.
+
+To upgrade, change all 'simple-git/promise' imports to just 'simple-git'
+=============================================`);
+
+const simpleGit = require('.');
+
+module.exports = Object.assign(
+   function () {
+      return simpleGit.gitP.apply(null, arguments);
+   },
+   simpleGit,
+   { default: simpleGit.gitP }
+);

package/dist/server/actions/git-actions.d.ts

@@ -0,0 +1,13 @@
+import { Context } from '@nocobase/actions';
+export declare function clone(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function pull(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function push(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function fetch(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function diff(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function status(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function log(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function branches(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function checkout(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function fileTree(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function fileContent(ctx: Context, next: () => Promise<void>): Promise<void>;
+export declare function commitDetail(ctx: Context, next: () => Promise<void>): Promise<void>;

package/dist/server/actions/git-actions.js

@@ -0,0 +1,354 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var git_actions_exports = {};
+__export(git_actions_exports, {
+  branches: () => branches,
+  checkout: () => checkout,
+  clone: () => clone,
+  commitDetail: () => commitDetail,
+  diff: () => diff,
+  fetch: () => fetch,
+  fileContent: () => fileContent,
+  fileTree: () => fileTree,
+  log: () => log,
+  pull: () => pull,
+  push: () => push,
+  status: () => status
+});
+module.exports = __toCommonJS(git_actions_exports);
+var import_simple_git = __toESM(require("simple-git"));
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+const REF_PATTERN = /^[a-zA-Z0-9._\-\/]+$/;
+const repoLocks = /* @__PURE__ */ new Map();
+function acquireLock(key) {
+  const prev = repoLocks.get(key) || Promise.resolve();
+  let release;
+  const next = new Promise((resolve) => {
+    release = resolve;
+  });
+  const promise = prev.then(() => {
+  });
+  repoLocks.set(key, next);
+  return { promise, release };
+}
+function validateRef(ref) {
+  if (!REF_PATTERN.test(ref)) {
+    throw new Error(`Invalid ref: ${ref}`);
+  }
+  return ref;
+}
+function validateBranch(branch) {
+  if (!branch || !REF_PATTERN.test(branch)) {
+    throw new Error(`Invalid branch name: ${branch}`);
+  }
+  return branch;
+}
+function validateRepoUrl(repoUrl) {
+  let parsed;
+  try {
+    parsed = new URL(repoUrl);
+  } catch {
+    throw new Error("Invalid repository URL");
+  }
+  if (parsed.protocol !== "https:") {
+    throw new Error("Only HTTPS repository URLs are allowed");
+  }
+}
+async function withAuth(git, repoUrl, pat, fn) {
+  const lockKey = repoUrl;
+  const lock = acquireLock(lockKey);
+  await lock.promise;
+  const authUrl = getAuthUrl(repoUrl, pat);
+  await git.remote(["set-url", "origin", authUrl]);
+  try {
+    return await fn();
+  } finally {
+    await git.remote(["set-url", "origin", repoUrl]);
+    lock.release();
+  }
+}
+function getAuthUrl(repoUrl, pat) {
+  const url = new URL(repoUrl);
+  url.username = "oauth2";
+  url.password = pat;
+  return url.toString();
+}
+function getGit(localPath) {
+  return (0, import_simple_git.default)(localPath);
+}
+async function getRepo(ctx) {
+  const { repositoryId } = ctx.action.params;
+  const repo = await ctx.db.getRepository("gitRepositories").findOne({
+    filterByTk: repositoryId
+  });
+  if (!repo) {
+    ctx.throw(404, "Repository not found");
+  }
+  return repo;
+}
+function validateLocalPath(localPath) {
+  const basePath = process.env.GIT_REPOS_BASE_PATH || path.join(process.cwd(), "storage", "git-repos");
+  const resolved = path.resolve(basePath, localPath);
+  const strictBasePath = path.resolve(basePath) + path.sep;
+  if (!resolved.startsWith(strictBasePath) && resolved !== path.resolve(basePath)) {
+    throw new Error("Invalid local path: path traversal detected or path is outside the allowed base directory");
+  }
+  return resolved;
+}
+async function clone(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const repoUrl = repo.get("repoUrl");
+  const pat = repo.get("pat");
+  validateRepoUrl(repoUrl);
+  if (fs.existsSync(localPath)) {
+    ctx.throw(400, "Directory already exists. Remove it before cloning again.");
+  }
+  if (!fs.existsSync(path.dirname(localPath))) {
+    fs.mkdirSync(path.dirname(localPath), { recursive: true });
+  }
+  const authUrl = getAuthUrl(repoUrl, pat);
+  try {
+    await (0, import_simple_git.default)().clone(authUrl, localPath, ["--branch", repo.get("defaultBranch") || "main"]);
+    await (0, import_simple_git.default)(localPath).remote(["set-url", "origin", repoUrl]);
+    await ctx.db.getRepository("gitRepositories").update({
+      filterByTk: repo.get("id"),
+      values: { status: "connected" }
+    });
+    ctx.body = { success: true, message: "Repository cloned successfully" };
+  } catch (err) {
+    await ctx.db.getRepository("gitRepositories").update({
+      filterByTk: repo.get("id"),
+      values: { status: "error" }
+    });
+    throw err;
+  }
+  await next();
+}
+async function pull(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const pat = repo.get("pat");
+  const repoUrl = repo.get("repoUrl");
+  const git = getGit(localPath);
+  const result = await withAuth(git, repoUrl, pat, () => git.pull());
+  ctx.body = { success: true, data: result };
+  await next();
+}
+async function push(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const pat = repo.get("pat");
+  const repoUrl = repo.get("repoUrl");
+  const git = getGit(localPath);
+  const result = await withAuth(git, repoUrl, pat, () => git.push());
+  ctx.body = { success: true, data: result };
+  await next();
+}
+async function fetch(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const pat = repo.get("pat");
+  const repoUrl = repo.get("repoUrl");
+  const git = getGit(localPath);
+  const result = await withAuth(git, repoUrl, pat, () => git.fetch());
+  ctx.body = { success: true, data: result };
+  await next();
+}
+async function diff(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const { file, commitHash, compareHash } = ctx.action.params;
+  const git = getGit(localPath);
+  const args = [];
+  if (commitHash && compareHash) {
+    args.push(validateRef(commitHash), validateRef(compareHash));
+  } else if (commitHash) {
+    args.push(validateRef(commitHash) + "^", validateRef(commitHash));
+  }
+  if (file) {
+    if (file.includes("..")) ctx.throw(400, "Invalid file path");
+    args.push("--", file);
+  }
+  const result = await git.diff(args);
+  ctx.body = { success: true, data: result };
+  await next();
+}
+async function status(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const result = await getGit(localPath).status();
+  ctx.body = { success: true, data: result };
+  await next();
+}
+async function log(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const { maxCount = 50, file } = ctx.action.params;
+  const parsed = parseInt(maxCount, 10);
+  const options = { maxCount: Math.min(Math.max(parsed || 50, 1), 500) };
+  if (file) {
+    if (file.includes("..")) ctx.throw(400, "Invalid file path");
+    options.file = file;
+  }
+  const result = await getGit(localPath).log(options);
+  ctx.body = { success: true, data: result };
+  await next();
+}
+async function branches(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const result = await getGit(localPath).branch();
+  ctx.body = { success: true, data: result };
+  await next();
+}
+async function checkout(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const { branch } = ctx.action.params;
+  validateBranch(branch);
+  await getGit(localPath).checkout(branch);
+  ctx.body = { success: true, message: `Switched to branch ${branch}` };
+  await next();
+}
+async function fileTree(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const { ref = "HEAD", treePath = "" } = ctx.action.params;
+  const git = getGit(localPath);
+  validateRef(ref);
+  if (treePath && treePath.includes("..")) {
+    ctx.throw(400, "Invalid tree path");
+  }
+  const detailArgs = ["ls-tree", "-l", ref];
+  if (treePath) detailArgs.push(treePath + "/");
+  const detailedResult = await git.raw(detailArgs);
+  const items = detailedResult.trim().split("\n").filter(Boolean).map((line) => {
+    const match = line.match(/^(\d+)\s+(blob|tree)\s+([a-f0-9]+)\s+(-|\d+)\t(.+)$/);
+    if (!match) return null;
+    const fullPath = match[5];
+    const name = fullPath.includes("/") ? fullPath.split("/").pop() : fullPath;
+    return {
+      mode: match[1],
+      type: match[2],
+      hash: match[3],
+      size: match[4] === "-" ? 0 : parseInt(match[4], 10),
+      name,
+      path: treePath ? `${treePath}/${name}` : name
+    };
+  }).filter(Boolean);
+  items.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "tree" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  ctx.body = { success: true, data: items };
+  await next();
+}
+async function fileContent(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const { ref = "HEAD", filePath } = ctx.action.params;
+  if (!filePath) {
+    ctx.throw(400, "filePath is required");
+  }
+  if (filePath.includes("..")) {
+    ctx.throw(400, "Invalid file path");
+  }
+  validateRef(ref);
+  const git = getGit(localPath);
+  const content = await git.show([`${ref}:${filePath}`]);
+  ctx.body = { success: true, data: { content, filePath, ref } };
+  await next();
+}
+async function commitDetail(ctx, next) {
+  const repo = await getRepo(ctx);
+  const localPath = validateLocalPath(repo.get("localPath"));
+  const { commitHash } = ctx.action.params;
+  if (!commitHash) {
+    ctx.throw(400, "commitHash is required");
+  }
+  const git = getGit(localPath);
+  validateRef(commitHash);
+  const DELIM_ARG = "%x00";
+  const DELIM_OUT = "\0";
+  const format = `%H${DELIM_ARG}%an${DELIM_ARG}%ae${DELIM_ARG}%aI${DELIM_ARG}%s${DELIM_ARG}%b`;
+  const [show, diffResult] = await Promise.all([
+    git.show([commitHash, "--stat", `--format=${format}`]),
+    git.diff([`${commitHash}^`, commitHash, "--name-status"]).catch(
+      () => (
+        // Root commit has no parent — use diff-tree --root instead
+        git.raw(["diff-tree", "--root", "--name-status", "-r", commitHash])
+      )
+    )
+  ]);
+  const parts = show.split(DELIM_OUT);
+  const files = diffResult.trim().split("\n").filter(Boolean).map((line) => {
+    const [statusCode, ...fileParts] = line.split("	");
+    return { status: statusCode, file: fileParts.join("	") };
+  });
+  ctx.body = {
+    success: true,
+    data: {
+      hash: parts[0] || "",
+      author: parts[1] || "",
+      email: parts[2] || "",
+      date: parts[3] || "",
+      subject: parts[4] || "",
+      body: (parts[5] || "").split("\n\n")[0].trim(),
+      // body before --stat output
+      files,
+      raw: show
+    }
+  };
+  await next();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  branches,
+  checkout,
+  clone,
+  commitDetail,
+  diff,
+  fetch,
+  fileContent,
+  fileTree,
+  log,
+  pull,
+  push,
+  status
+});

package/dist/server/collections/gitRepositories.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;