@hed-hog/cli 0.0.90 → 0.0.92

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hed-hog/cli",
-    "version": "0.0.90",
+    "version": "0.0.92",
     "description": "HedHog CLI tool",
     "author": "HedHog",
     "private": false,

package/dist/src/modules/developer/developer.service.d.ts

@@ -28,8 +28,11 @@ export declare class DeveloperService {
     private generateRandomHexSecret;
     private generateRandomBase64Secret;
     private maskDatabaseUrl;
+    private extractGithubRepositoryFromValue;
+    private detectGithubRepository;
     private resolveGithubRepository;
     private promptForDatabaseUrl;
+    private promptForDigitalOceanAccessToken;
     private setGithubSecret;
     private promptToConfigureGithubSecrets;
     private checkHelm;

package/dist/src/modules/developer/developer.service.js

@@ -188,7 +188,7 @@ let DeveloperService = class DeveloperService {
             spinner.succeed(chalk.green('Deployment configuration completed successfully!'));
             // Display summary
             this.displayDeploymentSummary(config);
-            await this.promptToConfigureGithubSecrets(path, repo);
+            await this.promptToConfigureGithubSecrets(path, repo, config.provider);
         }
         catch (error) {
             spinner.fail('Failed to configure deployment.');
@@ -247,20 +247,52 @@ let DeveloperService = class DeveloperService {
     maskDatabaseUrl(databaseUrl) {
         return databaseUrl.replace(/:\/\/([^:/?#]+):([^@]*)@/, '://$1:***@');
     }
-    async resolveGithubRepository(path, repo) {
-        if (repo?.trim()) {
-            return repo.trim();
+    extractGithubRepositoryFromValue(value) {
+        const normalizedValue = String(value || '').trim();
+        if (!normalizedValue) {
+            return undefined;
+        }
+        if (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(normalizedValue)) {
+            return normalizedValue;
         }
+        const match = normalizedValue.match(/github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?(?:[/?#].*)?$/i);
+        return match?.[1]?.replace(/\.git$/i, '');
+    }
+    async detectGithubRepository(path) {
         try {
             const result = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['remote', 'get-url', 'origin'], { cwd: path }, true);
-            const remoteUrl = result.stdout.trim();
-            const match = remoteUrl.match(/github\.com[:/]([^/]+\/[^/.]+?)(?:\.git)?$/i);
-            if (match?.[1]) {
-                return match[1];
+            const detectedRepo = this.extractGithubRepositoryFromValue(result.stdout.trim());
+            if (detectedRepo) {
+                return detectedRepo;
             }
         }
         catch {
-            // Fall through to prompt.
+            // Fall through to local project metadata.
+        }
+        try {
+            const packageJsonPath = pathModule.join(path, 'package.json');
+            if (!(0, fs_1.existsSync)(packageJsonPath)) {
+                return undefined;
+            }
+            const packageJsonRaw = await (0, promises_1.readFile)(packageJsonPath, 'utf8');
+            const packageJson = JSON.parse(packageJsonRaw);
+            const repositoryValue = typeof packageJson.repository === 'string'
+                ? packageJson.repository
+                : packageJson.repository?.url;
+            return this.extractGithubRepositoryFromValue(repositoryValue);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async resolveGithubRepository(path, repo) {
+        const explicitRepo = this.extractGithubRepositoryFromValue(repo);
+        if (explicitRepo) {
+            return explicitRepo;
+        }
+        const detectedRepo = await this.detectGithubRepository(path);
+        if (detectedRepo) {
+            return detectedRepo;
         }
         while (true) {
             const answers = await inquirer_1.default.prompt([
@@ -276,7 +308,7 @@ let DeveloperService = class DeveloperService {
                     },
                 },
             ]);
-            const resolvedRepo = String(answers.repo || '').trim();
+            const resolvedRepo = this.extractGithubRepositoryFromValue(answers.repo);
             if (resolvedRepo) {
                 return resolvedRepo;
             }
@@ -299,10 +331,28 @@ let DeveloperService = class DeveloperService {
             }
         }
     }
+    async promptForDigitalOceanAccessToken() {
+        while (true) {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'password',
+                    name: 'digitaloceanAccessToken',
+                    message: 'Enter DIGITALOCEAN_ACCESS_TOKEN:',
+                    mask: '*',
+                    validate: (input) => String(input || '').trim().length > 0 ||
+                        'DIGITALOCEAN_ACCESS_TOKEN is required.',
+                },
+            ]);
+            const token = String(answers.digitaloceanAccessToken || '').trim();
+            if (token) {
+                return token;
+            }
+        }
+    }
     async setGithubSecret(secretName, secretValue, repo) {
         await this.runner.executeCommand(runner_service_1.ProgramName.GH, ['secret', 'set', secretName, '--repo', repo, '--body', secretValue], {}, true);
     }
-    async promptToConfigureGithubSecrets(path, repo) {
+    async promptToConfigureGithubSecrets(path, repo, provider) {
         const { configureSecrets } = await inquirer_1.default.prompt([
             {
                 type: 'confirm',
@@ -317,9 +367,13 @@ let DeveloperService = class DeveloperService {
         }
         console.log(chalk.blue.bold('\n🔐 GitHub Secrets Setup\n'));
         await this.ensureGhAuthenticated();
+        const requiresDigitalOceanToken = provider === 'digitalocean';
         const resolvedRepo = await this.resolveGithubRepository(path, repo);
         const secretsConfig = {
             databaseUrl: await this.promptForDatabaseUrl(),
+            digitaloceanAccessToken: requiresDigitalOceanToken
+                ? await this.promptForDigitalOceanAccessToken()
+                : undefined,
             jwtSecret: this.generateRandomHexSecret(32),
             encryptionSecret: this.generateRandomBase64Secret(32),
             pepper: this.generateRandomBase64Secret(16),
@@ -327,6 +381,9 @@ let DeveloperService = class DeveloperService {
         const maskedDatabaseUrl = this.maskDatabaseUrl(secretsConfig.databaseUrl);
         console.log(chalk.gray(`Repository: ${chalk.cyan(resolvedRepo)}`));
         console.log(chalk.white(`DATABASE_URL:      ${maskedDatabaseUrl}`));
+        if (secretsConfig.digitaloceanAccessToken) {
+            console.log(chalk.white('DIGITALOCEAN_ACCESS_TOKEN: [provided] (hidden for safety)'));
+        }
         console.log(chalk.white(`JWT_SECRET:        ${secretsConfig.jwtSecret.substring(0, 16)}... (64 chars hex)`));
         console.log(chalk.white(`ENCRYPTION_SECRET: ${secretsConfig.encryptionSecret.substring(0, 16)}... (base64, 32 bytes)`));
         console.log(chalk.white(`PEPPER:            ${secretsConfig.pepper.substring(0, 8)}... (base64, 16 bytes)`));
@@ -349,6 +406,9 @@ let DeveloperService = class DeveloperService {
             await this.setGithubSecret('JWT_SECRET', secretsConfig.jwtSecret, resolvedRepo);
             await this.setGithubSecret('ENCRYPTION_SECRET', secretsConfig.encryptionSecret, resolvedRepo);
             await this.setGithubSecret('PEPPER', secretsConfig.pepper, resolvedRepo);
+            if (secretsConfig.digitaloceanAccessToken) {
+                await this.setGithubSecret('DIGITALOCEAN_ACCESS_TOKEN', secretsConfig.digitaloceanAccessToken, resolvedRepo);
+            }
             spinner.succeed(chalk.green(`GitHub secrets configured successfully for ${resolvedRepo}.`));
             console.log(chalk.gray(`Verify with: gh secret list --repo ${resolvedRepo}`));
             console.log('');