vg-coder-cli 2.0.22 → 2.0.23

package/vetgo-auto/chrome/src/controllers/common.firebase.ts

@@ -0,0 +1,31 @@
+import firebase from 'firebase/compat/app';
+import 'firebase/compat/firestore';
+import "firebase/compat/database";
+import { EnvironmentStorageService } from '../utils/environment-storage.service';
+
+// Không export trực tiếp biến đã khởi tạo nữa vì cần chờ async config
+// export const FirebaseDatabase = firebase.database();
+
+let initializedApp: firebase.app.App = null;
+
+export const getFirebaseDatabase = async () => {
+  if (!initializedApp) {
+    // Lấy config từ storage hoặc mặc định
+    const config = await EnvironmentStorageService.getFirebaseConfig();
+
+    // Kiểm tra xem đã có app nào tên mặc định chưa để tránh lỗi duplicate app
+    if (firebase.apps.length === 0) {
+      initializedApp = firebase.initializeApp(config);
+    } else {
+      // Nếu đã có rồi (do reload extension context) thì dùng lại, 
+      // nhưng nếu config thay đổi thì cần logic phức tạp hơn (xóa app cũ). 
+      // Ở đây giả định đơn giản là dùng app hiện tại hoặc tái khởi tạo nếu cần.
+      // Với extension service worker, biến toàn cục có thể bị reset.
+
+      // Để an toàn, ta delete app cũ và init lại với config mới nhất
+      await firebase.app().delete().catch(() => { });
+      initializedApp = firebase.initializeApp(config);
+    }
+  }
+  return initializedApp.database();
+};

package/vetgo-auto/chrome/src/controllers/firebase-crud.ts

@@ -0,0 +1,147 @@
+import * as cloneDeep from 'lodash/cloneDeep';
+import { uuid } from "../utils/db-utils";
+interface EntityModel {
+  id?: string; // Optional for new entities
+  seqNo: number;
+  deleted: boolean;
+}
+export function firebaseSerialize<T>(object: T) {
+  return cloneDeep(object);
+}
+export class RealtimeDbCrud<T extends EntityModel> {
+  constructor(
+    protected database: any
+  ) {
+    this.database = database;
+  }
+  getCurrentTimestamp() {
+    return new Date().getTime();
+  }
+
+  addAll(list, collectionName: string) {
+    const updates = {};
+    for (let item of list) {
+      if (!item.id) {
+        item.id = uuid();
+      }
+      item = { ...item, seqNo: this.getCurrentTimestamp(), deleted: false };
+      updates[`/${collectionName}/${item.id}`] = firebaseSerialize(item);
+    }
+    return this.database.ref().update(updates).then(() => list);
+  }
+
+  list(collectionName: string) {
+    return new Promise((resolve, reject) => {
+      this.database
+        .ref(collectionName)
+        .once('value')
+        .then((snapshot) => {
+          const data = snapshot.val();
+          const list = Object.keys(data).map((key) => ({ id: key, ...data[key] }));
+          resolve(list);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  }
+  // work okie
+  getRT(id: string,collectionName: string, callback: (item: T) => void ) {
+    const databaseRef = this.database.ref(`${collectionName}/${id}`);
+    databaseRef.on('value', (snapshot) => {
+      const data = snapshot.val();
+      if (data) {
+        callback(data);
+      } else {
+        callback(null);
+      }
+    });
+  }
+  // work okie
+  get(id: string,collectionName: string) {
+    return new Promise((resolve, reject) => {
+      this.database
+        .ref(`${collectionName}/${id}`)
+        .once('value')
+        .then((snapshot) => {
+          const data = snapshot.val();
+          if (data) {
+            console.log(data);
+            resolve({ id, ...data });
+          } else {
+            resolve(null);
+          }
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  }
+
+  add(entity, collectionName: string) {
+    entity = { ...entity, seqNo: this.getCurrentTimestamp(), deleted: false };
+    return new Promise((resolve, reject) => {
+      if (entity.id) {
+        const saveData = firebaseSerialize(entity);
+        this.database
+          .ref(`${collectionName}/${entity.id}`)
+          .set(saveData)
+          .then(() => {
+            resolve(entity);
+          })
+          .catch((error) => {
+            reject(error);
+          });
+      } else {
+        const id = uuid();
+        const newEntity = { id, ...entity };
+        this.database
+          .ref(collectionName)
+          .push(firebaseSerialize(newEntity))
+          .then(() => {
+            resolve(newEntity);
+          })
+          .catch((error) => {
+            reject(error);
+          });
+      }
+    });
+  }
+
+  update(entity, collectionName: string) {
+    return this.add(entity, collectionName );
+  }
+
+  listBySeq(maxSeqNo, collectionName: string) {
+    return new Promise((resolve, reject) => {
+      this.database
+        .ref(collectionName)
+        .orderByChild('seqNo')
+        .startAt(maxSeqNo)
+        .once('value')
+        .then((snapshot) => {
+          const data = snapshot.val();
+          const list = Object.keys(data).map((key) => ({ id: key, ...data[key] }));
+          resolve(list);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  }
+
+  delete(entity,collectionName: string) {
+    entity = { ...entity, seqNo: this.getCurrentTimestamp(), deleted: true };
+    return new Promise((resolve, reject) => {
+      this.database
+        .ref(`${collectionName}/${entity.id}`)
+        .set(firebaseSerialize(entity))
+        .then(() => {
+          resolve(entity);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  }
+}

package/vetgo-auto/chrome/src/controllers/load-common-fuc.controller.ts

@@ -0,0 +1,24 @@
+import { getFirebaseDatabase } from './common.firebase';
+import { RealtimeDbCrud } from "./firebase-crud";
+import { EnvironmentStorageService } from "../utils/environment-storage.service";
+
+const COMMON_FUC = 'COMMON-FUNC';
+
+export module CommonFunc {
+  export const load = async (): Promise<any> => {
+    const environmentName = await EnvironmentStorageService.getEnvironmentName();
+    
+    // Khởi tạo DB async
+    const database = await getFirebaseDatabase();
+    const db = new RealtimeDbCrud<any>(database);
+    
+    const list = await db.list(`ENV/${environmentName}/script`) as any[];
+    const l = (list || []).filter((it: any) => it.domain === COMMON_FUC && it.actionType === 'MAIN');
+
+    if (l.length !== 0) {
+      return l[0].code;
+    } else {
+      return `console.log('empty...${COMMON_FUC}')`;
+    }
+  }
+}

package/vetgo-auto/chrome/src/controllers/load-script.controller.ts

@@ -0,0 +1,23 @@
+import { getFirebaseDatabase } from './common.firebase';
+import { RealtimeDbCrud } from "./firebase-crud";
+import { EnvironmentStorageService } from "../utils/environment-storage.service";
+
+export module LoadScriptController {
+
+  export const loadScriptByDomain = async (domain: string, actionType: string): Promise<any> => {
+    const environmentName = await EnvironmentStorageService.getEnvironmentName();
+    
+    // Khởi tạo DB async
+    const database = await getFirebaseDatabase();
+    const db = new RealtimeDbCrud<any>(database);
+    
+    const list = await db.list(`ENV/${environmentName}/script`) as any[];
+    const l = (list || []).filter((it: any) => it.domain === domain && it.actionType === actionType.toUpperCase());
+
+    if (l.length !== 0) {
+      return l[0].code;
+    } else {
+      return "console.log('empty...')";
+    }
+  }
+}

package/vetgo-auto/chrome/src/script-injector.ts

@@ -0,0 +1,305 @@
+// Alternative script injection methods for CSP-restricted environments
+
+export class ScriptInjector {
+
+  /**
+   * Detect if site has strict CSP that blocks blob/data URLs
+   */
+  private static detectStrictCSP(): boolean {
+    try {
+      // Check for CSP meta tags
+      const cspMetas = document.querySelectorAll('meta[http-equiv="Content-Security-Policy"]');
+      for (let i = 0; i < cspMetas.length; i++) {
+        const meta = cspMetas[i];
+        const content = meta.getAttribute('content') || '';
+        if (content.includes('script-src') && !content.includes('blob:') && !content.includes('data:')) {
+          return true;
+        }
+      }
+
+      // Check common strict CSP domains
+      const strictDomains = [
+        'midjourney.com',
+        'openai.com',
+        'github.com',
+        'google.com',
+        'googletagmanager.com',
+        'facebook.com',
+        'twitter.com',
+        'linkedin.com'
+      ];
+
+      const hostname = window.location.hostname.toLowerCase();
+      return strictDomains.some(domain => hostname.includes(domain));
+    } catch (error) {
+      console.error('CSP detection error:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Safely get head element or wait for it
+   */
+  private static getHeadElement(): Promise<HTMLHeadElement> {
+    return new Promise((resolve) => {
+      const tryGetHead = () => {
+        const head = document.head || document.getElementsByTagName('head')[0];
+        if (head) {
+          resolve(head as HTMLHeadElement);
+          return;
+        }
+
+        // If no head, wait for DOM
+        if (document.readyState === 'loading') {
+          document.addEventListener('DOMContentLoaded', tryGetHead, { once: true });
+        } else {
+          // Create head if it doesn't exist
+          const newHead = document.createElement('head');
+          if (document.documentElement) {
+            document.documentElement.appendChild(newHead);
+            resolve(newHead);
+          } else {
+            // Last resort: wait a bit and try again
+            setTimeout(tryGetHead, 100);
+          }
+        }
+      };
+
+      tryGetHead();
+    });
+  }
+
+  /**
+   * Method 1: Blob URL injection (works in most cases)
+   */
+  static async injectViaBlob(script: string, actionType: string): Promise<boolean> {
+    try {
+      const blob = new Blob([script], { type: 'application/javascript' });
+      const blobUrl = URL.createObjectURL(blob);
+
+      const scriptElement = document.createElement('script');
+      scriptElement.type = 'text/javascript';
+      scriptElement.id = actionType;
+      scriptElement.src = blobUrl;
+
+      return new Promise(async (resolve) => {
+        scriptElement.onload = () => {
+          URL.revokeObjectURL(blobUrl);
+          resolve(true);
+        };
+
+        scriptElement.onerror = () => {
+          URL.revokeObjectURL(blobUrl);
+          resolve(false);
+        };
+
+        try {
+          const head = await this.getHeadElement();
+          head.appendChild(scriptElement);
+        } catch (error) {
+          console.error('Failed to get head element:', error);
+          URL.revokeObjectURL(blobUrl);
+          resolve(false);
+        }
+      });
+    } catch (error) {
+      console.error('Blob injection failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Method 2: Data URL injection (fallback)
+   */
+  static async injectViaDataUrl(script: string, actionType: string): Promise<boolean> {
+    try {
+      const dataUrl = 'data:application/javascript;base64,' + btoa(script);
+      const scriptElement = document.createElement('script');
+      scriptElement.type = 'text/javascript';
+      scriptElement.id = actionType + '_data';
+      scriptElement.src = dataUrl;
+
+      return new Promise(async (resolve) => {
+        scriptElement.onload = () => resolve(true);
+        scriptElement.onerror = () => resolve(false);
+
+        try {
+          const head = await this.getHeadElement();
+          head.appendChild(scriptElement);
+        } catch (error) {
+          console.error('Failed to get head element for data URL:', error);
+          resolve(false);
+        }
+      });
+    } catch (error) {
+      console.error('Data URL injection failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Method 3: PostMessage bridge injection
+   */
+  static injectViaPostMessage(script: string, actionType: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      try {
+        // Create a bridge script that listens for postMessage
+        const bridgeScript = `
+          window.addEventListener('message', function(event) {
+            if (event.source !== window || !event.data.type || event.data.type !== 'VETGO_SCRIPT_INJECT') {
+              return;
+            }
+            try {
+              const func = new Function(event.data.script);
+              func();
+              window.postMessage({type: 'VETGO_SCRIPT_SUCCESS', actionType: event.data.actionType}, '*');
+            } catch (error) {
+              console.error('PostMessage script execution failed:', error);
+              window.postMessage({type: 'VETGO_SCRIPT_ERROR', actionType: event.data.actionType, error: error.message}, '*');
+            }
+          });
+        `;
+        
+        // First inject the bridge
+        this.injectViaBlob(bridgeScript, actionType + '_bridge').then((bridgeSuccess) => {
+          if (bridgeSuccess) {
+            // Listen for response
+            const responseHandler = (event: MessageEvent) => {
+              if (event.source !== window || !event.data.type) return;
+              
+              if (event.data.type === 'VETGO_SCRIPT_SUCCESS' && event.data.actionType === actionType) {
+                window.removeEventListener('message', responseHandler);
+                resolve(true);
+              } else if (event.data.type === 'VETGO_SCRIPT_ERROR' && event.data.actionType === actionType) {
+                window.removeEventListener('message', responseHandler);
+                resolve(false);
+              }
+            };
+            
+            window.addEventListener('message', responseHandler);
+            
+            // Send script via postMessage
+            window.postMessage({
+              type: 'VETGO_SCRIPT_INJECT',
+              script: script,
+              actionType: actionType
+            }, '*');
+            
+            // Timeout after 5 seconds
+            setTimeout(() => {
+              window.removeEventListener('message', responseHandler);
+              resolve(false);
+            }, 5000);
+          } else {
+            resolve(false);
+          }
+        });
+      } catch (error) {
+        console.error('PostMessage injection failed:', error);
+        resolve(false);
+      }
+    });
+  }
+
+  /**
+   * Method 4: Background script injection via chrome.scripting
+   */
+  static injectViaBackground(script: string, actionType: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      try {
+        chrome.runtime.sendMessage({
+          action: "INJECT_SCRIPT",
+          script: script,
+          actionType: actionType
+        }, (response) => {
+          if (chrome.runtime.lastError) {
+            console.error('Background injection failed:', chrome.runtime.lastError);
+            resolve(false);
+          } else {
+            resolve(response && response.success);
+          }
+        });
+      } catch (error) {
+        console.error('Background script injection failed:', error);
+        resolve(false);
+      }
+    });
+  }
+
+  /**
+   * Method 5: Direct eval in content script context (last resort)
+   */
+  static injectViaEval(script: string, actionType: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      try {
+        console.log(`Attempting direct eval for ${actionType}`);
+
+        // Create isolated function to avoid polluting global scope
+        const isolatedExecution = new Function('script', `
+          try {
+            ${script}
+            return true;
+          } catch (error) {
+            console.error('Eval execution error:', error);
+            return false;
+          }
+        `);
+
+        const success = isolatedExecution(script);
+        resolve(success);
+      } catch (error) {
+        console.error('Eval injection failed:', error);
+        resolve(false);
+      }
+    });
+  }
+
+  /**
+   * Try all methods in smart order based on CSP detection
+   */
+  static async injectScript(script: string, actionType: string): Promise<boolean> {
+    const hasStrictCSP = this.detectStrictCSP();
+
+    // Smart method ordering based on CSP detection
+    const methods = hasStrictCSP ? [
+      // For strict CSP sites, try background injection first
+      () => this.injectViaBackground(script, actionType),
+      () => this.injectViaEval(script, actionType),
+      () => this.injectViaPostMessage(script, actionType),
+      () => this.injectViaBlob(script, actionType),
+      () => this.injectViaDataUrl(script, actionType)
+    ] : [
+      // For normal sites, try blob first (fastest)
+      () => this.injectViaBlob(script, actionType),
+      () => this.injectViaDataUrl(script, actionType),
+      () => this.injectViaBackground(script, actionType),
+      () => this.injectViaEval(script, actionType),
+      () => this.injectViaPostMessage(script, actionType)
+    ];
+
+    console.log(`Injecting script for ${actionType} (Strict CSP: ${hasStrictCSP})`);
+
+    for (let i = 0; i < methods.length; i++) {
+      const method = methods[i];
+      const methodName = hasStrictCSP ?
+        ['Background', 'Eval', 'PostMessage', 'Blob', 'DataURL'][i] :
+        ['Blob', 'DataURL', 'Background', 'Eval', 'PostMessage'][i];
+
+      try {
+        console.log(`Trying ${methodName} injection...`);
+        const success = await method();
+        if (success) {
+          console.log(`✅ Script injection successful via ${methodName} for ${actionType}`);
+          return true;
+        } else {
+          console.log(`❌ ${methodName} injection failed for ${actionType}`);
+        }
+      } catch (error) {
+        console.error(`❌ ${methodName} injection error:`, error);
+      }
+    }
+
+    console.error(`❌ All injection methods failed for ${actionType}`);
+    return false;
+  }
+}

package/vetgo-auto/chrome/src/sidepanel.css

@@ -0,0 +1,166 @@
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  min-height: 100vh;
+  display: flex;
+  align-items: flex-start;
+  justify-content: center;
+  padding: 0;
+}
+
+.container {
+  background: white;
+  border-radius: 0;
+  box-shadow: none;
+  padding: 24px;
+  width: 100%;
+  min-height: 100vh;
+}
+
+h1 {
+  color: #333;
+  font-size: 24px;
+  margin-bottom: 8px;
+  font-weight: 600;
+}
+
+.subtitle {
+  color: #666;
+  font-size: 13px;
+  margin-bottom: 24px;
+}
+
+.form-group {
+  margin-bottom: 20px;
+}
+
+label {
+  display: block;
+  color: #444;
+  font-size: 13px;
+  font-weight: 500;
+  margin-bottom: 6px;
+}
+
+input[type="text"] {
+  width: 100%;
+  padding: 10px 12px;
+  border: 2px solid #e0e0e0;
+  border-radius: 6px;
+  font-size: 14px;
+  transition: all 0.3s ease;
+  outline: none;
+}
+
+input[type="text"]:focus {
+  border-color: #667eea;
+  box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+}
+
+.hint {
+  color: #888;
+  font-size: 11px;
+  margin-top: 4px;
+  font-style: italic;
+}
+
+.button-group {
+  display: flex;
+  gap: 10px;
+  margin-top: 24px;
+}
+
+button {
+  flex: 1;
+  padding: 10px 20px;
+  border: none;
+  border-radius: 6px;
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  outline: none;
+}
+
+.btn-primary {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+}
+
+.btn-primary:hover {
+  transform: translateY(-1px);
+  box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+}
+
+.btn-primary:active {
+  transform: translateY(0);
+}
+
+.btn-secondary {
+  background: #f5f5f5;
+  color: #666;
+}
+
+.btn-secondary:hover {
+  background: #e0e0e0;
+}
+
+.message {
+  padding: 10px 14px;
+  border-radius: 6px;
+  margin-bottom: 16px;
+  font-size: 13px;
+  display: none;
+  animation: slideIn 0.3s ease;
+}
+
+@keyframes slideIn {
+  from {
+    opacity: 0;
+    transform: translateY(-10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.message.success {
+  background: #d4edda;
+  color: #155724;
+  border: 1px solid #c3e6cb;
+  display: block;
+}
+
+.message.error {
+  background: #f8d7da;
+  color: #721c24;
+  border: 1px solid #f5c6cb;
+  display: block;
+}
+
+.current-value {
+  background: #f8f9fa;
+  padding: 10px 14px;
+  border-radius: 6px;
+  margin-bottom: 16px;
+  border-left: 4px solid #667eea;
+}
+
+.current-value strong {
+  color: #667eea;
+  font-weight: 600;
+  font-size: 13px;
+}
+
+.current-value span {
+  color: #333;
+  font-family: 'Courier New', monospace;
+  font-size: 13px;
+}