gitnexus 1.6.5-rc.5 → 1.6.5-rc.7

package/dist/server/git-clone.js

@@ -10,6 +10,7 @@ import os from 'os';
 import fs from 'fs/promises';
 import { isIP } from 'net';
 import { logger } from '../core/logger.js';
+import { parseRepoNameFromUrl } from '../storage/git.js';
 /** Root directory for all cloned repositories. Targets must resolve inside this. */
 const CLONE_ROOT = path.resolve(path.join(os.homedir(), '.gitnexus', 'repos'));
 // A valid git repository name is filesystem-safe: alphanumerics plus `. _ -`.
@@ -25,19 +26,15 @@ const REPO_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
  * clone root via path traversal.
  */
 export function extractRepoName(url) {
-    // Strip trailing slashes without a regex to avoid polynomial-ReDoS on
-    // pathological inputs like `https://x.com/y` + '/'.repeat(1e6). CodeQL's
-    // js/polynomial-redos flagged `/\/+$/` here.
-    let end = url.length;
-    while (end > 0 && url.charCodeAt(end - 1) === 47 /* '/' */)
-        end--;
-    const cleaned = url.slice(0, end);
-    const lastSegment = cleaned.split(/[/:]/).pop() || '';
-    const stripped = lastSegment.endsWith('.git') ? lastSegment.slice(0, -4) : lastSegment;
-    if (!stripped || stripped === '.' || stripped === '..' || !REPO_NAME_PATTERN.test(stripped)) {
+    const name = parseRepoNameFromUrl(url);
+    if (!name ||
+        name === '.' ||
+        name === '..' ||
+        name === 'unknown' ||
+        !REPO_NAME_PATTERN.test(name)) {
         throw new Error('Could not extract a valid repository name from URL');
     }
-    return stripped;
+    return name;
 }
 /** Get the clone target directory for a repo name. */
 export function getCloneDir(repoName) {
@@ -347,8 +344,8 @@ export async function cloneOrPull(url, targetDir, onProgress) {
         throw new Error(`Clone target must be a subdirectory of ${CLONE_ROOT}`);
     }
     // Always validate the requested URL — the prior shape only ran this in
-    // the clone branch, leaving the pull branch as an SSRF / blocked-host
-    // bypass when an existing clone shared the basename of an attacker URL.
+    // the code path where the repo was cloned. Now it runs unconditionally,
+    // preventing SSRF / blocked-host bypasses even when targetDir already exists.
     validateGitUrl(url);
     const exists = await fs.access(path.join(safeTarget, '.git')).then(() => true, () => false);
     if (exists) {

package/dist/storage/git.d.ts

@@ -108,13 +108,24 @@ export declare const hasGitDir: (dirPath: string) => boolean;
  */
 export declare const getRemoteOriginUrl: (repoPath: string) => string | null;
 /**
- * Parse a repository name out of a git remote URL. Handles the common
- * SSH (`git@host:owner/repo.git`), HTTPS (`https://host/owner/repo.git`),
- * `git://`, `ssh://`, and `file://` shapes. Returns `null` for empty /
- * unparseable input.
+ * Sanitize a repository name to prevent argument injection and ensure
+ * cross-platform filesystem compatibility.
  *
- * The heuristic: strip a trailing `.git` and trailing slashes, then
- * take the segment after the last `/` or `:`.
+ * 1. Strips leading dashes to prevent git command-line argument injection
+ *    (e.g., --upload-pack=evil).
+ * 2. Replaces characters that are unsafe for directory names across
+ *    platforms (Windows/macOS/Linux) with underscores.
+ * 3. Blocks path traversal segments ("." and "..") and Windows reserved
+ *    names (e.g., CON, NUL) to prevent directory escape.
+ */
+export declare const sanitizeRepoName: (name: string) => string;
+/**
+ * Parse a repository name out of a git remote URL. Handles common shapes
+ * including SSH (git@host:owner/repo.git) and HTTPS (https://host/owner/repo.git).
+ *
+ * Returns a sanitized, filesystem-safe name or null if no name could be inferred.
+ * Returning null (rather than 'unknown') allows callers to use ?? null-coalescing
+ * for fallbacks without risk of registry collisions on 'unknown'.
  */
 export declare const parseRepoNameFromUrl: (url: string | null | undefined) => string | null;
 /**

package/dist/storage/git.js

@@ -257,13 +257,36 @@ export const getRemoteOriginUrl = (repoPath) => {
     }
 };
 /**
- * Parse a repository name out of a git remote URL. Handles the common
- * SSH (`git@host:owner/repo.git`), HTTPS (`https://host/owner/repo.git`),
- * `git://`, `ssh://`, and `file://` shapes. Returns `null` for empty /
- * unparseable input.
+ * Sanitize a repository name to prevent argument injection and ensure
+ * cross-platform filesystem compatibility.
  *
- * The heuristic: strip a trailing `.git` and trailing slashes, then
- * take the segment after the last `/` or `:`.
+ * 1. Strips leading dashes to prevent git command-line argument injection
+ *    (e.g., --upload-pack=evil).
+ * 2. Replaces characters that are unsafe for directory names across
+ *    platforms (Windows/macOS/Linux) with underscores.
+ * 3. Blocks path traversal segments ("." and "..") and Windows reserved
+ *    names (e.g., CON, NUL) to prevent directory escape.
+ */
+export const sanitizeRepoName = (name) => {
+    // 1. Prevent argument injection by stripping leading dashes.
+    // 2. Remove characters that are not alphanumerics, dots, underscores, or dashes.
+    const sanitized = name.replace(/^-+/, '').replace(/[^a-zA-Z0-9._-]/g, '_');
+    // 3. Block path traversal segments and Windows reserved names.
+    // Windows reserved names like CON, PRN, AUX, NUL, COM1-9, LPT1-9 cannot
+    // be used as directory names on Windows even if they have an extension.
+    const reserved = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\..*)?$/i;
+    if (!sanitized || sanitized === '.' || sanitized === '..' || reserved.test(sanitized)) {
+        return 'unknown';
+    }
+    return sanitized;
+};
+/**
+ * Parse a repository name out of a git remote URL. Handles common shapes
+ * including SSH (git@host:owner/repo.git) and HTTPS (https://host/owner/repo.git).
+ *
+ * Returns a sanitized, filesystem-safe name or null if no name could be inferred.
+ * Returning null (rather than 'unknown') allows callers to use ?? null-coalescing
+ * for fallbacks without risk of registry collisions on 'unknown'.
  */
 export const parseRepoNameFromUrl = (url) => {
     if (!url)
@@ -271,12 +294,23 @@ export const parseRepoNameFromUrl = (url) => {
     const trimmed = url.trim();
     if (!trimmed)
         return null;
-    // Strip `.git` suffix (case-insensitive) and any trailing slashes.
-    const withoutSuffix = trimmed.replace(/\.git\/*$/i, '').replace(/\/+$/, '');
-    // Last path segment, splitting on either `/` or `:` (covers SSH form).
-    const m = withoutSuffix.match(/[/:]([^/:]+)$/);
-    const candidate = m ? m[1] : withoutSuffix;
-    return candidate || null;
+    // Strip trailing slashes without a regex to avoid polynomial-ReDoS on
+    // pathological inputs like `https://x.com/y` + '/'.repeat(1e6).
+    let end = trimmed.length;
+    while (end > 0 && trimmed.charCodeAt(end - 1) === 47 /* '/' */)
+        end--;
+    let cleaned = trimmed.slice(0, end);
+    // Strip trailing .git (case-insensitive)
+    if (cleaned.toLowerCase().endsWith('.git')) {
+        cleaned = cleaned.slice(0, -4);
+    }
+    // Last path segment, handling colons for SSH URLs and path traversal.
+    // Split on both / and : to consistently extract the last part.
+    const candidate = cleaned.split(/[/:]/).pop() || '';
+    if (!candidate)
+        return null;
+    const safe = sanitizeRepoName(candidate);
+    return safe === 'unknown' ? null : safe;
 };
 /**
  * Convenience wrapper: derive a registry-friendly name from the repo's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5-rc.5",
+  "version": "1.6.5-rc.7",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",