git-ripper 1.5.3 → 1.6.0

package/README.md

@@ -94,14 +94,16 @@ git-ripper https://github.com/username/repository/tree/branch/folder --zip="my-a
 ### Command Line Options
 
 | Option                     | Description                              | Default           |
-| -------------------------- | ---------------------------------------- | ----------------- |
+| -------------------------- | ---------------------------------------- | ----------------- | --- | -------------------------- | ------------------------- | --- |
 | `-o, --output <directory>` | Specify output directory                 | Current directory |
 | `--gh-token <token>`       | GitHub Personal Access Token             | -                 |
 | `--zip [filename]`         | Create ZIP archive of downloaded content | -                 |
 | `--no-resume`              | Disable resume functionality             | -                 |
 | `--force-restart`          | Ignore existing checkpoints and restart  | -                 |
-| `--list-checkpoints`       | List all saved download checkpoints      | -                 |
-| `-V, --version`            | Show version number                      | -                 |
+| `--list-checkpoints`       | List all saved download checkpoints      | -                 |     | `config set-token <token>` | Save GitHub token locally | -   |
+| `config get-token`         | Show saved token (masked)                | -                 |
+| `config remove-token`      | Remove saved token                       | -                 |
+| `config show`              | Show current configuration               | -                 |     | `-V, --version`            | Show version number       | -   |
 | `-h, --help`               | Show help                                | -                 |
 
 ## Authentication (Private Repositories & Rate Limits)
@@ -136,12 +138,62 @@ You can use either a **Fine-grained token** (Recommended) or a **Classic token**
 
 ### Using the Token
 
+#### Option 1: Save Token Locally (Recommended)
+
+Save your token once and use it automatically for all future downloads:
+
+```bash
+# Save the token
+git-ripper config set-token ghp_YourTokenHere
+
+# Now just download - token is used automatically
+git-ripper https://github.com/username/private-repo/tree/main/src
+```
+
+#### Option 2: Environment Variable
+
+Set the `GIT_RIPPER_TOKEN` environment variable:
+
+```bash
+# Windows (PowerShell)
+$env:GIT_RIPPER_TOKEN = "ghp_YourTokenHere"
+
+# Linux/Mac
+export GIT_RIPPER_TOKEN="ghp_YourTokenHere"
+
+# Then download
+git-ripper https://github.com/username/private-repo/tree/main/src
+```
+
+#### Option 3: Command Line Flag
+
 Pass the token using the `--gh-token` flag:
 
 ```bash
 git-ripper https://github.com/username/private-repo/tree/main/src --gh-token ghp_YourTokenHere
 ```
 
+#### Token Priority
+
+When multiple tokens are available, git-ripper uses this priority:
+
+1. `--gh-token` command line flag (highest)
+2. `GIT_RIPPER_TOKEN` environment variable
+3. Saved token from `config set-token`
+
+#### Managing Saved Tokens
+
+```bash
+# View current configuration
+git-ripper config show
+
+# View saved token (masked)
+git-ripper config get-token
+
+# Remove saved token
+git-ripper config remove-token
+```
+
 > **Security Note:** Be careful not to share your token or commit it to public repositories.
 
 ## Examples

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-ripper",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "CLI tool that lets you download specific folders from GitHub repositories without cloning the entire repo.",
   "main": "src/index.js",
   "type": "module",

package/src/configManager.js

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import chalk from "chalk";
+
+/**
+ * Configuration manager for git-ripper
+ * Handles persistent storage of settings like GitHub tokens
+ */
+class ConfigManager {
+  constructor() {
+    this.configDir = path.join(os.homedir(), ".git-ripper");
+    this.configFile = path.join(this.configDir, "config.json");
+  }
+
+  /**
+   * Ensures the config directory exists
+   * @private
+   */
+  _ensureConfigDir() {
+    if (!fs.existsSync(this.configDir)) {
+      fs.mkdirSync(this.configDir, { recursive: true, mode: 0o700 });
+    }
+  }
+
+  /**
+   * Loads the configuration from disk
+   * @returns {Object} - The configuration object
+   */
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configFile)) {
+        const data = fs.readFileSync(this.configFile, "utf8");
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      // If config is corrupted, return empty config
+      console.warn(
+        chalk.yellow(`Warning: Could not read config file: ${error.message}`),
+      );
+    }
+    return {};
+  }
+
+  /**
+   * Saves the configuration to disk
+   * @param {Object} config - The configuration object to save
+   */
+  saveConfig(config) {
+    this._ensureConfigDir();
+    try {
+      fs.writeFileSync(this.configFile, JSON.stringify(config, null, 2), {
+        encoding: "utf8",
+        mode: 0o600, // Read/write for owner only
+      });
+    } catch (error) {
+      throw new Error(`Failed to save config: ${error.message}`);
+    }
+  }
+
+  /**
+   * Sets the GitHub token in the config
+   * @param {string} token - The GitHub Personal Access Token
+   */
+  setToken(token) {
+    if (!token || typeof token !== "string" || token.trim() === "") {
+      throw new Error("Token cannot be empty");
+    }
+
+    const config = this.loadConfig();
+    config.github_token = token.trim();
+    config.token_saved_at = new Date().toISOString();
+    this.saveConfig(config);
+  }
+
+  /**
+   * Gets the GitHub token from config
+   * @returns {string|null} - The token or null if not set
+   */
+  getToken() {
+    const config = this.loadConfig();
+    return config.github_token || null;
+  }
+
+  /**
+   * Removes the GitHub token from config
+   * @returns {boolean} - True if token was removed, false if no token existed
+   */
+  removeToken() {
+    const config = this.loadConfig();
+    if (config.github_token) {
+      delete config.github_token;
+      delete config.token_saved_at;
+      this.saveConfig(config);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Gets the token with priority: CLI flag > env var > stored config
+   * @param {string|null} cliToken - Token passed via CLI flag
+   * @returns {string|null} - The resolved token or null
+   */
+  resolveToken(cliToken = null) {
+    // Priority 1: CLI flag
+    if (cliToken) {
+      return cliToken;
+    }
+
+    // Priority 2: Environment variable
+    const envToken = process.env.GIT_RIPPER_TOKEN;
+    if (envToken) {
+      return envToken;
+    }
+
+    // Priority 3: Stored config
+    return this.getToken();
+  }
+
+  /**
+   * Masks a token for display (shows first 4 and last 4 characters)
+   * @param {string} token - The token to mask
+   * @returns {string} - The masked token
+   */
+  maskToken(token) {
+    if (!token || token.length < 12) {
+      return "****";
+    }
+    return `${token.substring(0, 4)}${"*".repeat(token.length - 8)}${token.substring(token.length - 4)}`;
+  }
+
+  /**
+   * Shows the current configuration
+   * @returns {Object} - Configuration summary
+   */
+  showConfig() {
+    const config = this.loadConfig();
+    const envToken = process.env.GIT_RIPPER_TOKEN;
+
+    return {
+      hasStoredToken: !!config.github_token,
+      maskedToken:
+        config.github_token ? this.maskToken(config.github_token) : null,
+      tokenSavedAt: config.token_saved_at || null,
+      hasEnvToken: !!envToken,
+      configPath: this.configFile,
+    };
+  }
+
+  /**
+   * Gets the path to the config file
+   * @returns {string} - The config file path
+   */
+  getConfigPath() {
+    return this.configFile;
+  }
+}
+
+export { ConfigManager };

package/src/index.js

@@ -7,6 +7,7 @@ import {
 } from "./downloader.js";
 import { downloadAndArchive } from "./archiver.js";
 import { ResumeManager } from "./resumeManager.js";
+import { ConfigManager } from "./configManager.js";
 import { fileURLToPath } from "node:url";
 import { dirname, join, resolve, basename } from "node:path";
 import fs from "node:fs";
@@ -61,6 +62,90 @@ const validateOutputDirectory = (outputDir) => {
 };
 
 const initializeCLI = () => {
+  const configManager = new ConfigManager();
+
+  // Add config subcommand
+  const configCmd = program
+    .command("config")
+    .description("Manage git-ripper configuration");
+
+  configCmd
+    .command("set-token <token>")
+    .description("Save GitHub Personal Access Token locally")
+    .action((token) => {
+      try {
+        configManager.setToken(token);
+        console.log(chalk.green("Token saved successfully!"));
+        console.log(
+          chalk.yellow(
+            "Security note: Keep your config file secure. Location: " +
+              configManager.getConfigPath(),
+          ),
+        );
+      } catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  configCmd
+    .command("get-token")
+    .description("Show saved GitHub token (masked)")
+    .action(() => {
+      const token = configManager.getToken();
+      if (token) {
+        console.log(`Saved token: ${configManager.maskToken(token)}`);
+      } else {
+        console.log(chalk.yellow("No token saved."));
+        console.log(
+          "Use 'git-ripper config set-token <token>' to save a token.",
+        );
+      }
+    });
+
+  configCmd
+    .command("remove-token")
+    .description("Remove saved GitHub token")
+    .action(() => {
+      if (configManager.removeToken()) {
+        console.log(chalk.green("Token removed successfully."));
+      } else {
+        console.log(chalk.yellow("No token was saved."));
+      }
+    });
+
+  configCmd
+    .command("show")
+    .description("Show current configuration")
+    .action(() => {
+      const config = configManager.showConfig();
+      console.log(chalk.cyan("\nGit-ripper Configuration:"));
+      console.log(`  Config file: ${config.configPath}`);
+      console.log(
+        `  Stored token: ${
+          config.hasStoredToken ?
+            chalk.green(config.maskedToken)
+          : chalk.gray("Not set")
+        }`,
+      );
+      if (config.tokenSavedAt) {
+        console.log(
+          `  Token saved: ${new Date(config.tokenSavedAt).toLocaleString()}`,
+        );
+      }
+      console.log(
+        `  Environment token (GIT_RIPPER_TOKEN): ${
+          config.hasEnvToken ? chalk.green("Set") : chalk.gray("Not set")
+        }`,
+      );
+      console.log(
+        chalk.gray(
+          "\n  Token priority: --gh-token flag > GIT_RIPPER_TOKEN env > stored token",
+        ),
+      );
+      console.log();
+    });
+
   program
     .version(packageJson.version)
     .description("Clone specific folders from GitHub repositories")
@@ -187,11 +272,21 @@ const initializeCLI = () => {
         const archiveName =
           typeof options.zip === "string" ? options.zip : null;
 
+        // Resolve token with priority: CLI flag > env var > stored config
+        const resolvedToken = configManager.resolveToken(options.ghToken);
+        if (resolvedToken && !options.ghToken) {
+          const source =
+            process.env.GIT_RIPPER_TOKEN ?
+              "environment variable"
+            : "saved config";
+          console.log(chalk.gray(`Using GitHub token from ${source}`));
+        }
+
         // Prepare download options
         const downloadOptions = {
           resume: options.resume !== false, // Default to true unless --no-resume
           forceRestart: options.forceRestart || false,
-          token: options.ghToken,
+          token: resolvedToken,
         };
 
         let operationType = createArchive ? "archive" : "download";
@@ -217,7 +312,7 @@ const initializeCLI = () => {
               parsedUrl.branch,
               parsedUrl.folderPath,
               outputPath,
-              options.ghToken,
+              resolvedToken,
             );
           } else {
             console.log(`Downloading folder to: ${options.output}`);