Spookfox

Basic access to browser's tabs.

Inject Javascript into the browser. From a web extension's pov, there are three places to inject JS in:

1. The background script; which can be considered the addon itself.
2. The content script; which runs inside a web-page e.g on youtube.com
3. The popup; which runs in addon's popup-ui page. This is the popup you see when you click the addon's icon in top browser bar.

This app provide following functions:

• spookfox-js-injection-eval-in-active-tab

  spookfox-js-injection-eval-in-active-tab is a byte-compiled Lisp function in ‘spookfox-js-injection.el’.

  (spookfox-js-injection-eval-in-active-tab JS &optional JUST-THE-TIP-P)

  Evaluate JS in active firefox tab. Return value is a list of lists. Browser can have multiple active tabs (one per window). Every active tab can have multiple frames. If JUST-THE-TIP-P is non-nil, first tab’s first frame’s return value from the results is returned (instead of list of lists).

  JS is subjected to limitations of browser’s ability to execute it. It is similar to executing js in browser’s console. So for example running a script which declares a variable with ‘let‘ or ‘const‘ might cause the script to fail execution.

  Details about js execution: https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript

Inject Javascript into any website open in your browser's active tab, and get the results back. I use it to help me take notes for Youtube videos with automatically added timestamp links.

• spookfox-js-injection-eval

  spookfox-js-injection-eval is a Lisp closure in ‘/mnt/data/channi-documents/work/spookfox/lisp/apps/spookfox-js-injection.el’.

  (spookfox-js-injection-eval JS &optional (CONTEXT 'background) (SELECT-TAB-P nil))

  Evaluate JS in CONTEXT. Return the result of evaluation.

  Supported contexts:

  1. background Eval JS in addon’s background page.
  2. tab Eval JS in tab. When non-nil SELECT-TAB-P should be a function which receives each tab (a plist of at least :url, :id, :title, :windowId), and JS is evaluated in every tab for which it returns non-nil.

Spookfox ships JSCL compiler, which can be used to run a subset of common-lisp in the browser. For example:

(sfcl-eval
   `(progn
      (js:browser:tabs:update ,tab-id ,(sfcl-js-obj '(("active" . t))))
      (js:browser:windows:update ,window-id ,(sfcl-js-obj '(("focused" . t))))
      t))

spookfox-tabs.el use jscl for spookfox-switch-tab

Following functions are available:

• spookfox-jscl-eval

  spookfox-jscl-eval is a byte-compiled Lisp function in ‘spookfox-jscl.el’.

  (spookfox-jscl-eval FORM &optional (CONTEXT 'background))

  Evaluate LISP FORM in background script in CONTEXT. CONTEXT can be one of (background).

  Note: JSCL uses #j: for FFI, but FORM must use ‘js:‘ for that, because emacs-lisp do not allow writing #j: forms, even in quoted form.

To make it a little easier to work with JS from CL, following utility functions can be used:

• spookfox-jscl-js-obj

  spookfox-jscl-js-obj is a byte-compiled Lisp function in ‘spookfox-jscl.el’.

  (spookfox-jscl-js-obj ALIST)

  Create a javascript object from ALIST.

⚠️ I am not using this app myself anymore. It is the most buggy of 'em all. I am keeping it around because list of my open tabs is increasing again, and I might once again need this.

Manage browser's tabs in an org file (separate file or as a subtree in an existing one).

Spookfox has a request-response model. You can register custom request handlers in Emacs to run Elisp code which is triggered from browser e.g using a JavaScript bookmarklet. For this you need to do 2 things:

1. Add a handle for request in Emacs

   Here is some example code for registering a request handler:

   (defun my--capture-the-flag (url)
     (raise-frame)
     (message "CAPTURING THE FLAG: %s" url))
   
   (spookfox--register-req-handler "CAPTURE_THE_FLAG" #'my--capture-the-flag)
   

2. Send a request from browser

   postMessage({
     type: 'SPOOKFOX_RELAY_TO_EMACS',
     action: {
       name: 'CAPTURE_THE_FLAG',
       payload: { url: window.location.href }
     }
   })
   

   action part here decides which request handler will execute. Elisp version of payload will be provided to your request-handler as an argument.

js-injection spookfox app can be used to send requests from Emacs to browser, and even get results back. e.g to get current tab's URL, we can use

(spookfox-js-injection-eval-in-active-tab "window.location.href" t)
;; => "https://github.com/bitspook/spookfox/issues/38"

spookfox-js-injection-eval-in-active-tab runs js in current-window's active tab. js-injection also enable running JS in any tab (and even addon's background script) with more general purpose spookfox-js-injection-eval.

E.g run following code to run a script in all tabs which are visiting bitspook.in:

(spookfox-js-injection-eval
 "console.log('Hello from Emacs'); 5 + 5;"
 'tab
 (lambda (tab)
   (s-contains-p "bitspook.in" (plist-get tab :url))))