@geekmidas/cli 9.0.2 → 10.0.0-alpha.1

package/src/auth/__tests__/index.spec.ts

@@ -1,237 +0,0 @@
-import { existsSync } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { HttpResponse, http } from 'msw';
-import { setupServer } from 'msw/node';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import {
-	getDokployCredentials,
-	removeDokployCredentials,
-	storeDokployCredentials,
-} from '../credentials';
-import { maskToken, validateDokployToken } from '../index';
-
-// MSW server for mocking API calls
-const server = setupServer();
-
-describe('auth commands', () => {
-	let tempDir: string;
-
-	beforeEach(async () => {
-		tempDir = join(tmpdir(), `gkm-auth-cmd-test-${Date.now()}`);
-		await mkdir(tempDir, { recursive: true });
-		server.listen({ onUnhandledRequest: 'bypass' });
-	});
-
-	afterEach(async () => {
-		server.resetHandlers();
-		server.close();
-		if (existsSync(tempDir)) {
-			await rm(tempDir, { recursive: true });
-		}
-	});
-
-	describe('validateDokployToken', () => {
-		it('should return true for valid token', async () => {
-			server.use(
-				http.get('https://dokploy.example.com/api/project.all', () => {
-					return HttpResponse.json([{ projectId: 'proj_1', name: 'Test' }]);
-				}),
-			);
-
-			const result = await validateDokployToken(
-				'https://dokploy.example.com',
-				'valid-token',
-			);
-
-			expect(result).toBe(true);
-		});
-
-		it('should return false for invalid token (401)', async () => {
-			server.use(
-				http.get('https://dokploy.example.com/api/project.all', () => {
-					return new HttpResponse(null, { status: 401 });
-				}),
-			);
-
-			const result = await validateDokployToken(
-				'https://dokploy.example.com',
-				'invalid-token',
-			);
-
-			expect(result).toBe(false);
-		});
-
-		it('should return false for server error (500)', async () => {
-			server.use(
-				http.get('https://dokploy.example.com/api/project.all', () => {
-					return new HttpResponse(null, { status: 500 });
-				}),
-			);
-
-			const result = await validateDokployToken(
-				'https://dokploy.example.com',
-				'token',
-			);
-
-			expect(result).toBe(false);
-		});
-
-		it('should return false on network error', async () => {
-			server.use(
-				http.get('https://dokploy.example.com/api/project.all', () => {
-					return HttpResponse.error();
-				}),
-			);
-
-			const result = await validateDokployToken(
-				'https://dokploy.example.com',
-				'token',
-			);
-
-			expect(result).toBe(false);
-		});
-	});
-
-	describe('maskToken', () => {
-		it('should mask long tokens showing first and last 4 chars', () => {
-			expect(maskToken('abcdefghijklmnop')).toBe('abcd...mnop');
-		});
-
-		it('should fully mask tokens 8 chars or less', () => {
-			expect(maskToken('short')).toBe('****');
-			expect(maskToken('12345678')).toBe('****');
-		});
-
-		it('should handle exactly 9 character token', () => {
-			expect(maskToken('123456789')).toBe('1234...6789');
-		});
-
-		it('should handle very long tokens', () => {
-			const longToken = 'a'.repeat(100);
-			expect(maskToken(longToken)).toBe('aaaa...aaaa');
-		});
-
-		it('should handle empty string', () => {
-			expect(maskToken('')).toBe('****');
-		});
-	});
-
-	describe('credentials flow', () => {
-		it('should store and retrieve credentials', async () => {
-			await storeDokployCredentials('my-token', 'https://dokploy.example.com', {
-				root: tempDir,
-			});
-
-			const creds = await getDokployCredentials({ root: tempDir });
-			expect(creds).not.toBeNull();
-			expect(creds!.token).toBe('my-token');
-			expect(creds!.endpoint).toBe('https://dokploy.example.com');
-		});
-
-		it('should remove credentials', async () => {
-			await storeDokployCredentials('my-token', 'https://dokploy.example.com', {
-				root: tempDir,
-			});
-
-			const removed = await removeDokployCredentials({ root: tempDir });
-			expect(removed).toBe(true);
-
-			const creds = await getDokployCredentials({ root: tempDir });
-			expect(creds).toBeNull();
-		});
-
-		it('should return false when removing non-existent credentials', async () => {
-			const removed = await removeDokployCredentials({ root: tempDir });
-			expect(removed).toBe(false);
-		});
-	});
-});
-
-describe('URL normalization', () => {
-	it('should remove trailing slash from endpoint', () => {
-		const endpoint = 'https://dokploy.example.com/'.replace(/\/$/, '');
-		expect(endpoint).toBe('https://dokploy.example.com');
-	});
-
-	it('should not modify endpoint without trailing slash', () => {
-		const endpoint = 'https://dokploy.example.com'.replace(/\/$/, '');
-		expect(endpoint).toBe('https://dokploy.example.com');
-	});
-
-	it('should validate URL format', () => {
-		expect(() => new URL('https://dokploy.example.com')).not.toThrow();
-		expect(() => new URL('invalid-url')).toThrow();
-	});
-});
-
-describe('logoutCommand', () => {
-	let tempDir: string;
-
-	beforeEach(async () => {
-		tempDir = join(tmpdir(), `gkm-logout-test-${Date.now()}`);
-		await mkdir(tempDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		if (existsSync(tempDir)) {
-			await rm(tempDir, { recursive: true });
-		}
-	});
-
-	it('should remove dokploy credentials', async () => {
-		// First store credentials
-		await storeDokployCredentials('my-token', 'https://dokploy.example.com', {
-			root: tempDir,
-		});
-
-		// Verify they exist
-		let creds = await getDokployCredentials({ root: tempDir });
-		expect(creds).not.toBeNull();
-
-		// Remove credentials
-		const removed = await removeDokployCredentials({ root: tempDir });
-		expect(removed).toBe(true);
-
-		// Verify they're gone
-		creds = await getDokployCredentials({ root: tempDir });
-		expect(creds).toBeNull();
-	});
-
-	it('should return false when no credentials to remove', async () => {
-		const removed = await removeDokployCredentials({ root: tempDir });
-		expect(removed).toBe(false);
-	});
-});
-
-describe('whoamiCommand helpers', () => {
-	let tempDir: string;
-
-	beforeEach(async () => {
-		tempDir = join(tmpdir(), `gkm-whoami-test-${Date.now()}`);
-		await mkdir(tempDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		if (existsSync(tempDir)) {
-			await rm(tempDir, { recursive: true });
-		}
-	});
-
-	it('should return null when no credentials stored', async () => {
-		const creds = await getDokployCredentials({ root: tempDir });
-		expect(creds).toBeNull();
-	});
-
-	it('should return credentials when stored', async () => {
-		await storeDokployCredentials('test-token', 'https://test.example.com', {
-			root: tempDir,
-		});
-
-		const creds = await getDokployCredentials({ root: tempDir });
-		expect(creds).not.toBeNull();
-		expect(creds!.endpoint).toBe('https://test.example.com');
-	});
-});

package/src/auth/credentials.ts

@@ -1,286 +0,0 @@
-import { existsSync, mkdirSync } from 'node:fs';
-import { readFile, unlink, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-/**
- * Stored credentials for various services
- */
-export interface StoredCredentials {
-	dokploy?: {
-		/** API token */
-		token: string;
-		/** Dokploy endpoint URL */
-		endpoint: string;
-		/** Registry ID in Dokploy (for Docker image pulls) */
-		registryId?: string;
-		/** When the credentials were stored */
-		storedAt: string;
-	};
-	hostinger?: {
-		/** API token from hpanel.hostinger.com/profile/api */
-		token: string;
-		/** When the credentials were stored */
-		storedAt: string;
-	};
-}
-
-/**
- * Options for credential operations
- */
-export interface CredentialOptions {
-	/** Root directory for credentials storage (default: user home directory) */
-	root?: string;
-}
-
-/**
- * Get the path to the credentials directory
- */
-export function getCredentialsDir(options?: CredentialOptions): string {
-	const root = options?.root ?? homedir();
-	return join(root, '.gkm');
-}
-
-/**
- * Get the path to the credentials file
- */
-export function getCredentialsPath(options?: CredentialOptions): string {
-	return join(getCredentialsDir(options), 'credentials.json');
-}
-
-/**
- * Ensure the credentials directory exists
- */
-function ensureCredentialsDir(options?: CredentialOptions): void {
-	const dir = getCredentialsDir(options);
-	if (!existsSync(dir)) {
-		mkdirSync(dir, { recursive: true, mode: 0o700 });
-	}
-}
-
-/**
- * Read stored credentials from disk
- */
-export async function readCredentials(
-	options?: CredentialOptions,
-): Promise<StoredCredentials> {
-	const path = getCredentialsPath(options);
-
-	if (!existsSync(path)) {
-		return {};
-	}
-
-	try {
-		const content = await readFile(path, 'utf-8');
-		return JSON.parse(content) as StoredCredentials;
-	} catch {
-		return {};
-	}
-}
-
-/**
- * Write credentials to disk
- */
-export async function writeCredentials(
-	credentials: StoredCredentials,
-	options?: CredentialOptions,
-): Promise<void> {
-	ensureCredentialsDir(options);
-	const path = getCredentialsPath(options);
-
-	await writeFile(path, JSON.stringify(credentials, null, 2), {
-		mode: 0o600, // Owner read/write only
-	});
-}
-
-/**
- * Store Dokploy credentials
- */
-export async function storeDokployCredentials(
-	token: string,
-	endpoint: string,
-	options?: CredentialOptions,
-): Promise<void> {
-	const credentials = await readCredentials(options);
-
-	credentials.dokploy = {
-		token,
-		endpoint,
-		storedAt: new Date().toISOString(),
-	};
-
-	await writeCredentials(credentials, options);
-}
-
-/**
- * Get stored Dokploy credentials
- */
-export async function getDokployCredentials(
-	options?: CredentialOptions,
-): Promise<{
-	token: string;
-	endpoint: string;
-	registryId?: string;
-} | null> {
-	const credentials = await readCredentials(options);
-
-	if (!credentials.dokploy) {
-		return null;
-	}
-
-	return {
-		token: credentials.dokploy.token,
-		endpoint: credentials.dokploy.endpoint,
-		registryId: credentials.dokploy.registryId,
-	};
-}
-
-/**
- * Remove Dokploy credentials
- */
-export async function removeDokployCredentials(
-	options?: CredentialOptions,
-): Promise<boolean> {
-	const credentials = await readCredentials(options);
-
-	if (!credentials.dokploy) {
-		return false;
-	}
-
-	delete credentials.dokploy;
-	await writeCredentials(credentials, options);
-	return true;
-}
-
-/**
- * Remove all stored credentials
- */
-export async function removeAllCredentials(
-	options?: CredentialOptions,
-): Promise<void> {
-	const path = getCredentialsPath(options);
-
-	if (existsSync(path)) {
-		await unlink(path);
-	}
-}
-
-/**
- * Get Dokploy API token, checking stored credentials first, then environment
- */
-export async function getDokployToken(
-	options?: CredentialOptions,
-): Promise<string | null> {
-	// First check environment variable (takes precedence)
-	const envToken = process.env.DOKPLOY_API_TOKEN;
-	if (envToken) {
-		return envToken;
-	}
-
-	// Then check stored credentials
-	const stored = await getDokployCredentials(options);
-	if (stored) {
-		return stored.token;
-	}
-
-	return null;
-}
-
-/**
- * Get Dokploy endpoint from stored credentials
- */
-export async function getDokployEndpoint(
-	options?: CredentialOptions,
-): Promise<string | null> {
-	const stored = await getDokployCredentials(options);
-	return stored?.endpoint ?? null;
-}
-
-/**
- * Store Dokploy registry ID
- */
-export async function storeDokployRegistryId(
-	registryId: string,
-	options?: CredentialOptions,
-): Promise<void> {
-	const credentials = await readCredentials(options);
-
-	if (!credentials.dokploy) {
-		throw new Error(
-			'Dokploy credentials not found. Run "gkm login --service dokploy" first.',
-		);
-	}
-
-	credentials.dokploy.registryId = registryId;
-	await writeCredentials(credentials, options);
-}
-
-/**
- * Get Dokploy registry ID from stored credentials
- */
-export async function getDokployRegistryId(
-	options?: CredentialOptions,
-): Promise<string | undefined> {
-	const stored = await getDokployCredentials(options);
-	return stored?.registryId ?? undefined;
-}
-
-// ============================================
-// Hostinger credentials
-// ============================================
-
-/**
- * Store Hostinger API token
- *
- * @param token - API token from hpanel.hostinger.com/profile/api
- */
-export async function storeHostingerToken(
-	token: string,
-	options?: CredentialOptions,
-): Promise<void> {
-	const credentials = await readCredentials(options);
-
-	credentials.hostinger = {
-		token,
-		storedAt: new Date().toISOString(),
-	};
-
-	await writeCredentials(credentials, options);
-}
-
-/**
- * Get stored Hostinger API token
- *
- * Checks environment variable first (HOSTINGER_API_TOKEN),
- * then falls back to stored credentials.
- */
-export async function getHostingerToken(
-	options?: CredentialOptions,
-): Promise<string | null> {
-	// First check environment variable (takes precedence)
-	const envToken = process.env.HOSTINGER_API_TOKEN;
-	if (envToken) {
-		return envToken;
-	}
-
-	// Then check stored credentials
-	const credentials = await readCredentials(options);
-	return credentials.hostinger?.token ?? null;
-}
-
-/**
- * Remove Hostinger credentials
- */
-export async function removeHostingerCredentials(
-	options?: CredentialOptions,
-): Promise<boolean> {
-	const credentials = await readCredentials(options);
-
-	if (!credentials.hostinger) {
-		return false;
-	}
-
-	delete credentials.hostinger;
-	await writeCredentials(credentials, options);
-	return true;
-}