Release (#125)

Author: escottalexander

.changeset/early-ads-sneeze.md

@@ -0,0 +1,5 @@
+---
+"eth-tech-tree": patch
+---
+
+fix ens resolution

.changeset/stale-papayas-wink.md

@@ -0,0 +1,5 @@
+---
+"eth-tech-tree": minor
+---
+
+Move config files from the `cwd` to the user's home directory `~/.eth-tech-tree` to prevent creating multiple config files when the command is run from different locations

src/actions/remove-storage.ts

@@ -1,13 +1,29 @@
 import fs from "fs";
 import path from "path";
+import { getConfigPath } from "../utils/state-manager";
 
 export function removeStorage() {
     console.log("Resetting storage...");
-    const configPath = path.join(process.cwd(), "storage");
-    if (!fs.existsSync(configPath)) {
+    
+    const configPath = getConfigPath();
+    let removedNew = false;
+    if (fs.existsSync(configPath)) {
+        fs.rmSync(configPath, { recursive: true });
+        removedNew = true;
+    }
+    
+    // Remove legacy storage location
+    const legacyPath = path.join(process.cwd(), "storage");
+    let removedLegacy = false;
+    if (fs.existsSync(legacyPath)) {
+        fs.rmSync(legacyPath, { recursive: true });
+        removedLegacy = true;
+    }
+    
+    if (!removedNew && !removedLegacy) {
         console.log("Storage does not exist. Nothing to reset.");
         return;
     }
-    fs.rmSync(configPath, { recursive: true });
+    
     console.log("Storage reset successfully.");
 }

src/modules/api.ts

@@ -73,6 +73,25 @@ export const submitChallengeToServer = async (userAddress: string, challengeName
   }
 };
 
+/**
+ * Get address from ENS name
+ */
+export const getEnsAddress = async (ensName: string) => {
+  try {
+    const response = await fetch(`${API_URL}/ens/${ensName}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error('Error:', error);
+    return { valid: false, error: 'Network error' };
+  }
+};
+
 /**
  * Fetch Leaderboard
  */

src/utils/helpers.ts

@@ -1,8 +1,7 @@
 import os from "os";
 import fs from "fs";
 import { IChallenge } from "../types";
-import { loadChallenges } from "./state-manager";
-import { fetchChallenges } from "../modules/api";
+import { fetchChallenges, getEnsAddress } from "../modules/api";
 import { Choice } from "../tasks/parse-command-arguments-and-options";
 
 export function wait(ms: number) {
@@ -29,12 +28,26 @@ export const checkValidPathOrCreate = async (path: string) => {
   }
 };
 
+export const isValidEns = async (name: string): Promise<boolean> => {
+  try {
+    const result = await getEnsAddress(name);
+    return result.address !== null;
+  } catch (error) {
+    console.error('Error validating ENS:', error);
+    return false;
+  }
+};
+
 export const isValidAddress = (value: string): boolean => {
     return /^0x[a-fA-F0-9]{40}$/.test(value)
 };
 
-export const isValidAddressOrENS = (value: string): boolean => {
-    return /^(0x[a-fA-F0-9]{40}|.+\.eth)$/.test(value);
+export const isValidAddressOrENS = async (value: string): Promise<string | boolean> => {
+  if (value.endsWith('.eth')) {
+    return await isValidEns(value) ? true : "Invalid ENS name";
+  } else {
+    return isValidAddress(value) ? true : "Invalid address";
+  }
 };
 
 export const getDevice = (): string => {

src/utils/state-manager.ts

@@ -1,51 +1,111 @@
 import fs from 'fs';
 import { promisify } from 'util';
 import path from 'path';
+import os from 'os';
 import { IChallenge, IUser } from '../types';
 
 const writeFile = promisify(fs.writeFile);
 
-export async function saveUserState(state: IUser) {
-  const configPath = path.join(process.cwd(), "storage");
+export function getConfigPath(): string {
+  return path.join(os.homedir(), '.eth-tech-tree', 'config');
+}
+
+function getLegacyConfigPath(): string {
+  return path.join(process.cwd(), "storage");
+}
+
+function ensureConfigExists(): void {
+  const configPath = getConfigPath();
   if (!fs.existsSync(configPath)) {
-    fs.mkdirSync(configPath);
+    fs.mkdirSync(configPath, { recursive: true });
   }
-  const filePath = path.join(configPath, "user.json");
-  await writeFile(filePath, JSON.stringify(state, null, 2));
 }
 
-export function loadUserState(): IUser {
+function migrateLegacyConfig(): void {
+  const legacyPath = getLegacyConfigPath();
+  const newPath = getConfigPath();
+  
+  if (fs.existsSync(legacyPath)) {
+    ensureConfigExists();
+    
+    let migratedAnyFiles = false;
+    
+    // Migrate user.json if it exists
+    const legacyUserFile = path.join(legacyPath, "user.json");
+    const newUserFile = path.join(newPath, "user.json");
+    if (fs.existsSync(legacyUserFile) && !fs.existsSync(newUserFile)) {
+      fs.copyFileSync(legacyUserFile, newUserFile);
+      fs.unlinkSync(legacyUserFile);
+      console.log("Migrated user config from local storage to home directory");
+      migratedAnyFiles = true;
+    }
+    
+    // Migrate challenges.json if it exists
+    const legacyChallengesFile = path.join(legacyPath, "challenges.json");
+    const newChallengesFile = path.join(newPath, "challenges.json");
+    if (fs.existsSync(legacyChallengesFile) && !fs.existsSync(newChallengesFile)) {
+      fs.copyFileSync(legacyChallengesFile, newChallengesFile);
+      fs.unlinkSync(legacyChallengesFile);
+      console.log("Migrated challenges config from local storage to home directory");
+      migratedAnyFiles = true;
+    }
+    
+    // Remove the legacy directory if it's empty after migration
+    if (migratedAnyFiles) {
+      try {
+        const remainingFiles = fs.readdirSync(legacyPath);
+        if (remainingFiles.length === 0) {
+          fs.rmdirSync(legacyPath);
+          console.log("Removed legacy storage directory");
+        }
+      } catch (error) {
+        // Ignore errors when trying to remove the directory
+        // (it might not be empty or we might not have permissions)
+      }
+    }
+  }
+}
+
+function loadConfigWithMigration<T>(filename: string, defaultValue: T): T {
   try {
-    const configPath = path.join(process.cwd(), "storage", `user.json`);
-    const data = fs.readFileSync(configPath, 'utf8');
-    return JSON.parse(data) as IUser;
+    const filePath = path.join(getConfigPath(), filename);
+    const data = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(data);
   } catch (error: any) {
     if (error.code === 'ENOENT') {
-      return {} as IUser; // Return empty object if file doesn't exist
+      migrateLegacyConfig();
+
+      try {
+        const filePath = path.join(getConfigPath(), filename);
+        const data = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(data);
+      } catch (migrationError: any) {
+        if (migrationError.code === 'ENOENT') {
+          return defaultValue; // Return default value if file doesn't exist even after migration
+        }
+        throw migrationError;
+      }
     }
     throw error;
   }
 }
 
-export async function saveChallenges(challenges: IChallenge[]) {
-  const configPath = path.join(process.cwd(), "storage");
+export async function saveUserState(state: IUser) {
+  ensureConfigExists();
+  const filePath = path.join(getConfigPath(), "user.json");
+  await writeFile(filePath, JSON.stringify(state, null, 2));
+}
 
-  if (!fs.existsSync(configPath)) {
-    fs.mkdirSync(configPath);
-  }
-  const filePath = path.join(configPath, "challenges.json");
+export function loadUserState(): IUser {
+  return loadConfigWithMigration("user.json", {} as IUser);
+}
+
+export async function saveChallenges(challenges: IChallenge[]) {
+  ensureConfigExists();
+  const filePath = path.join(getConfigPath(), "challenges.json");
   await writeFile(filePath, JSON.stringify(challenges, null, 2));
 }
 
 export function loadChallenges(): IChallenge[] {
-  try {
-    const configPath = path.join(process.cwd(), "storage", `challenges.json`);
-    const data = fs.readFileSync(configPath, 'utf8');
-    return JSON.parse(data);
-  } catch (error: any) {
-    if (error.code === 'ENOENT') {
-      return []; // Return empty array if file doesn't exist
-    }
-    throw error;
-  }
-}
+  return loadConfigWithMigration("challenges.json", []);
+}