ZeroOmega

https://github.com/zero-peak/zeroomega
Admin
ZeroOmega is a proxy management extension, forked from SwitchyOmega and compatible with manifest v3,...
Tokens:1,346
Snippets:6
Trust Score:4.4
License:GPL-3.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Build Project (npm)

Source: https://github.com/zero-peak/zeroomega/blob/master/README.md

Commands to install project dependencies and build the project for development and release using npm. This process generates build artifacts in specified folders.

```bash
cd omega-build
npm run deps
npm run dev
npm run build
npm run release
cd ../dist
```

--------------------------------

### WebExtension Target Implementation Example

Source: https://github.com/zero-peak/zeroomega/blob/master/README.md

This snippet illustrates the structure of a target-specific implementation, specifically for a WebExtension. It shows how to extend the abstract `OmegaTarget` and `Options` classes to handle browser-specific APIs like `chrome.storage.sync` for storing settings. Written in CoffeeScript.

```coffeescript
# Example: omega-target-chromium-extension/omega_target_web.coffee

# Assuming OmegaTarget and Options are imported/defined elsewhere

class ChromiumExtensionTarget extends OmegaTarget
  constructor: (@browserApi) ->
    super()
    @options = new ChromiumExtensionOptions(@browserApi)

  applyProfile: (profileName) ->
    # Implementation specific to Chromium extensions
    console.log "Applying profile: #{profileName} in Chromium"
    # Use browserApi.runtime.sendMessage or similar to communicate with background script

  # Other target-specific methods...

class ChromiumExtensionOptions extends Options
  constructor: (@browserApi) ->
    super()

  getOption: (key) ->
    new Promise (resolve) =>
      @browserApi.storage.sync.get(key, (result) =>
        resolve(result[key])
      )

  setOption: (key, value) ->
    new Promise (resolve) =>
      @browserApi.storage.sync.set({ [key]: value }, () =>
        resolve()
      )

# Usage example (conceptual):
# const target = new ChromiumExtensionTarget(chrome)
# target.applyProfile('MyProxyProfile')
```

--------------------------------

### Web-Based Configuration Interface (`omega-web`)

Source: https://github.com/zero-peak/zeroomega/blob/master/README.md

The `omega-web` component provides a web-based user interface for configuring options and profiles, working with `omega-target` as its backend. It requires a `omega_target_web.js` file for browser-dependent communication and state retrieval, often implemented using Angular. Written in JavaScript and HTML.

```javascript
// Conceptual structure for omega_target_web.js
// This file would typically be part of the target's build process.

// Assuming an Angular module named 'omegaTarget' is defined elsewhere
// and 'omega-target' backend logic is exposed via an API or direct calls.

// Example of how omega-target might be integrated (simplified)
// angular.module('omegaTarget', []).factory('omegaTargetService', ['$q', function($q) {
//   // Assume OmegaTargetBackend is a globally available object or imported module
//   // that provides browser-independent logic.
//   const backend = OmegaTargetBackend; 

//   return {
//     getProfiles: function() {
//       // Calls backend.getAllProfiles() or similar
//       return $q.when(backend.getAllProfiles());
//     },
//     saveProfile: function(profile) {
//       // Calls backend.saveProfile(profile)
//       return $q.when(backend.saveProfile(profile));
//     },
//     // ... other methods to interact with the backend ...
//   };
// }]);

// The HTML/CSS for the web interface would be separate.
// Example HTML structure (conceptual):
// <div class="profile-manager">
//   <h1>Profile Settings</h1>
//   <div ng-repeat="profile in profiles">
//     <input type="text" ng-model="profile.name" />
//     <!-- ... other profile settings ... -->
//   </div>
//   <button ng-click="addProfile()">Add Profile</button>
// </div>

```

--------------------------------

### Browser-Independent Options Manager (`omega-target`)

Source: https://github.com/zero-peak/zeroomega/blob/master/README.md

The `omega-target` folder contains browser-independent logic for managing options and applying profiles. Public methods are well-documented in comments. Subclasses are expected to implement browser-specific functions. Written in JavaScript.

```javascript
// Abstract base class for Options (conceptual)
class Options {
  constructor() {
    if (new.target === Options) {
      throw new TypeError("Cannot construct Abstract instances directly");
    }
  }

  // Abstract method to be implemented by subclasses
  async getOption(key) {
    throw new Error("Method 'getOption()' must be implemented.");
  }

  // Abstract method to be implemented by subclasses
  async setOption(key, value) {
    throw new Error("Method 'setOption()' must be implemented.");
  }

  // Other common methods for managing options...
}

// Example of a concrete implementation (browser-specific)
// class ChromiumOptions extends Options {
//   async getOption(key) {
//     return new Promise(resolve => {
//       chrome.storage.sync.get(key, (result) => {
//         resolve(result[key]);
//       });
//     });
//   }
//
//   async setOption(key, value) {
//     return new Promise(resolve => {
//       chrome.storage.sync.set({ [key]: value }, () => {
//         resolve();
//       });
//     });
//   }
// }
```

--------------------------------

### Enable Grunt Watch for Development (grunt)

Source: https://github.com/zero-peak/zeroomega/blob/master/README.md

Command to enable the `grunt watch` task for continuous development. This command should be run in the `omega-build` directory to activate watch mode across all modules.

```bash
grunt watch
```

--------------------------------

### PAC Generator Module (`omega-pac`)

Source: https://github.com/zero-peak/zeroomega/blob/master/README.md

The `omega-pac` module handles the profile model and compiles profiles into PAC scripts. It is designed to be a standalone module and can be published to npm once documentation is complete. It is written in JavaScript.

```javascript
// Example of PAC generation logic (conceptual, actual implementation may vary)
class OmegaPacGenerator {
  constructor(profiles) {
    this.profiles = profiles;
  }

  compileToPacScript() {
    let pacScript = "function FindProxyForURL(url, host) {";
    // Logic to iterate through profiles and generate PAC rules
    this.profiles.forEach(profile => {
      // ... profile compilation logic ...
    });
    pacScript += "\n  return \"DIRECT\"; // Default to direct connection\n}";
    return pacScript;
  }
}

// Usage example:
// const profiles = getProfiles(); // Assume this function retrieves profile data
// const pacGenerator = new OmegaPacGenerator(profiles);
// const pacScript = pacGenerator.compileToPacScript();
// console.log(pacScript);
```
Tokens:
Raw