NAME
    App::FirefoxUtils - Utilities related to Firefox

VERSION
    This document describes version 0.024 of App::FirefoxUtils (from Perl
    distribution App-FirefoxUtils), released on 2026-03-26.

SYNOPSIS
DESCRIPTION
    This distribution includes several utilities related to Firefox:

    1. firefox-has-processes
    2. firefox-is-paused
    3. firefox-is-running
    4. get-firefox-profile-dir
    5. kill-firefox
    6. list-firefox-profiles
    7. open-firefox-tabs
    8. pause-and-unpause-firefox
    9. pause-firefox
    10. ps-firefox
    11. restart-firefox
    12. start-firefox
    13. terminate-firefox
    14. unpause-firefox

FUNCTIONS
  firefox_has_processes
    Usage:

     firefox_has_processes(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Check whether Firefox has processes.

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   quiet => *true*

        (No description)

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  firefox_is_paused
    Usage:

     firefox_is_paused(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Check whether Firefox is paused.

    Firefox is defined as paused if *all* of its processes are in 'stop'
    state.

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   quiet => *true*

        (No description)

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  firefox_is_running
    Usage:

     firefox_is_running(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Check whether Firefox is running.

    Firefox is defined as running if there are some Firefox processes that
    are *not* in 'stop' state. In other words, if Firefox has been started
    but is currently paused, we do not say that it's running. If you want to
    check if Firefox process exists, you can use "ps_firefox".

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   quiet => *true*

        (No description)

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  open_firefox_tabs
    Usage:

     open_firefox_tabs(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Open a list of Firefox tabs, with options.

    This utility is best used via Perl or curried after you supply the list
    of items. For example, in script "open-my-tiktok":

     use App::FirefoxUtils ();
     use Perinci::CmdLine::Any;
     use Perinci::Sub::Util qw(gen_curried_sub);
 
     my @containers = (
         'account1',
         'account2',
         'account3',
     );
 
     my @containers_additional = (
         'account4',
         'account5',
     );
 
     gen_curried_sub(
         'App::FirefoxUtils::open_firefox_tabs',
         {
             items => [
                 (map { +{url=>'https://www.tiktok.com/', container=>$_} } @containers),
                 (map { +{url=>'https://www.tiktok.com/', container=>$_, include_by_default=>0} } @containers_additional),
             ],
         },
         'open_my_tiktok',
     );
 
     Perinci::CmdLine::Any->new(
         url => '/main/open_my_tiktok',
         log => 1,
     )->run;

    Later on, you run your script:

     # open all items that are included by default
     % open-my-tiktok
 
     # only open items that match the queries
     % open-my-tiktok account2 account3
 
     # only open items that do not contain 'account4'
     % open-my-tiktok --new-window --shuffle -- -account4

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   exclude_all_tags => *array[str]*

        Exclude all items that have ALL tags specified.

    *   exclude_any_tags => *array[str]*

        Exclude all items that have any tags specified.

    *   include_all_tags => *array[str]*

        Include all items that have ALL tags specified.

    *   include_any_tags => *array[str]*

        Include all items that have any tag specified.

    *   items* => *array[hash]*

        (No description)

    *   new_window => *bool*

        (No description)

    *   query => *array[str]*

        (No description)

    *   shuffle => *bool*

        (No description)

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  pause_and_unpause_firefox
    Usage:

     pause_and_unpause_firefox(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Pause and unpause Firefox alternately.

    A modern browser now runs complex web pages and applications. Despite
    browser's power management feature, these pages/tabs on the browser
    often still eat considerable CPU cycles even though they only run in the
    background. Pausing (kill -STOP) the browser processes is a simple and
    effective way to stop CPU eating on Unix and prolong your laptop battery
    life. It can be performed whenever you are not using your browser for a
    little while, e.g. when you are typing on an editor or watching a movie.
    When you want to use your browser again, simply unpause (kill -CONT) it.

    The "pause-and-unpause" action pause and unpause browser in an alternate
    fashion, by default every 5 minutes and 30 seconds. This is a compromise
    to save CPU time most of the time but then give time for web
    applications in the browser to catch up during the unpause window (e.g.
    for WhatsApp Web to display new messages and sound notification.) It can
    be used when you are not browsing but still want to be notified by web
    applications from time to time.

    If you run this routine, it will start pausing and unpausing browser.
    When you want to use the browser, press Ctrl-C to interrupt the routine.
    Then after you are done with the browser and want to pause-and-unpause
    again, you can re-run this routine.

    You can customize the periods via the "periods" option.

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   periods => *array[duration]*

        Pause and unpause times, in seconds.

        For example, to pause for 5 minutes, then unpause 10 seconds, then
        pause for 2 minutes, then unpause for 30 seconds (then repeat the
        pattern), you can use:

         300,10,120,30

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  pause_firefox
    Usage:

     pause_firefox(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Pause (kill -STOP) Firefox.

    A modern browser now runs complex web pages and applications. Despite
    browser's power management feature, these pages/tabs on the browser
    often still eat considerable CPU cycles even though they only run in the
    background. Pausing (kill -STOP) the browser processes is a simple and
    effective way to stop CPU eating on Unix and prolong your laptop battery
    life. It can be performed whenever you are not using your browser for a
    little while, e.g. when you are typing on an editor or watching a movie.
    When you want to use your browser again, simply unpause (kill -CONT) it.

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  ps_firefox
    Usage:

     ps_firefox(%args) -> [$status_code, $reason, $payload, \%result_meta]

    List Firefox processes.

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  restart_firefox
    Usage:

     restart_firefox(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Restart firefox.

    This function is not exported by default, but exportable.

    This function supports dry-run operation.

    Arguments ('*' denotes required arguments):

    *   firefox_cmd => *array[str]|str* (default: "firefox")

        (No description)

    *   quiet => *true*

        (No description)

    Special arguments:

    *   -dry_run => *bool*

        Pass -dry_run=>1 to enable simulation mode.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  start_firefox
    Usage:

     start_firefox(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Start firefox if not already started.

    This function is not exported by default, but exportable.

    This function supports dry-run operation.

    Arguments ('*' denotes required arguments):

    *   firefox_cmd => *array[str]|str* (default: "firefox")

        (No description)

    *   quiet => *true*

        (No description)

    Special arguments:

    *   -dry_run => *bool*

        Pass -dry_run=>1 to enable simulation mode.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  terminate_firefox
    Usage:

     terminate_firefox(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Terminate Firefox (by default with -KILL signal).

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   signal => *unix::signal*

        (No description)

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

  unpause_firefox
    Usage:

     unpause_firefox(%args) -> [$status_code, $reason, $payload, \%result_meta]

    Unpause (resume, continue, kill -CONT) Firefox.

    This function is not exported by default, but exportable.

    Arguments ('*' denotes required arguments):

    *   cmndline_pat => *re_from_str*

        Filter processes using regex against their cmndline.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   exec_pat => *re_from_str*

        Filter processes using regex against their exec.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   fname_pat => *re_from_str*

        Filter processes using regex against their fname.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   pid_pat => *re_from_str*

        Filter processes using regex against their pid.

        If one of the "*-pat" options are specified, then instead of the
        default heuristic rules to find the browser processes, these "*-pat"
        options are solely used to determine which processes are the browser
        processes.

    *   users => *array[unix::uid::exists]*

        Kill browser processes that belong to certain user(s) only.

    Returns an enveloped result (an array).

    First element ($status_code) is an integer containing HTTP-like status
    code (200 means OK, 4xx caller error, 5xx function error). Second
    element ($reason) is a string containing error message, or something
    like "OK" if status is 200. Third element ($payload) is the actual
    result, but usually not present when enveloped result is an error
    response ($status_code is not 2xx). Fourth element (%result_meta) is
    called result metadata and is optional, a hash that contains extra
    information, much like how HTTP response headers provide additional
    metadata.

    Return value: (any)

HOMEPAGE
    Please visit the project's homepage at
    <https://metacpan.org/release/App-FirefoxUtils>.

SOURCE
    Source repository is at
    <https://github.com/perlancar/perl-App-FirefoxUtils>.

SEE ALSO
    Some other CLI utilities related to Firefox: dump-firefox-history (from
    App::DumpFirefoxHistory), App::FirefoxMultiAccountContainersUtils.

    App::BraveUtils

    App::ChromeUtils

    App::OperaUtils

    App::VivaldiUtils

    App::BrowserUtils

AUTHOR
    perlancar <perlancar@cpan.org>

CONTRIBUTING
    To contribute, you can send patches by email/via RT, or send pull
    requests on GitHub.

    Most of the time, you don't need to build the distribution yourself. You
    can simply modify the code, then test via:

     % prove -l

    If you want to build the distribution (e.g. to try to install it locally
    on your system), you can install Dist::Zilla,
    Dist::Zilla::PluginBundle::Author::PERLANCAR,
    Pod::Weaver::PluginBundle::Author::PERLANCAR, and sometimes one or two
    other Dist::Zilla- and/or Pod::Weaver plugins. Any additional steps
    required beyond that are considered a bug and can be reported to me.

COPYRIGHT AND LICENSE
    This software is copyright (c) 2026 by perlancar <perlancar@cpan.org>.

    This is free software; you can redistribute it and/or modify it under
    the same terms as the Perl 5 programming language system itself.

BUGS
    Please report any bugs or feature requests on the bugtracker website
    <https://rt.cpan.org/Public/Dist/Display.html?Name=App-FirefoxUtils>

    When submitting a bug or request, please include a test-file or a patch
    to an existing test-file that illustrates the bug or desired feature.

