NAME
    App::BrowserUtils - Utilities related to browsers, particularly modern
    GUI ones

VERSION
    This document describes version 0.019 of App::BrowserUtils (from Perl
    distribution App-BrowserUtils), released on 2023-10-28.

SYNOPSIS
DESCRIPTION
    This distribution includes several utilities related to browsers:

    1. browsers-are-paused
    2. kill-browsers
    3. pause-and-unpause-browsers
    4. pause-browsers
    5. ps-browsers
    6. restart-browsers
    7. start-browsers
    8. terminate-browsers
    9. unpause-browsers

    Supported browsers: Firefox on Linux, Opera on Linux, Chrome on Linux,
    and Vivaldi on Linux.

FUNCTIONS
  browsers_are_paused
    Usage:

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

    Check whether browsers are paused.

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

    This function is not exported.

    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)

  pause_and_unpause_browsers
    Usage:

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

    Pause and unpause browsers 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.

    See also the separate "pause_browsers" and the "unpause_browsers"
    routines.

    This function is not exported.

    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_browsers
    Usage:

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

    Pause (kill -STOP) browsers.

    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.

    See also the "unpause_browsers" and the "pause_and_unpause_browsers"
    routines.

    This function is not exported.

    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_browsers
    Usage:

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

    List browser processes.

    This function is not exported.

    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_browsers
    Usage:

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

    Restart browsers.

    For each of the requested browser, first check whether browser processes
    (that run the current user) exist. If they do then terminate the browser
    first. After that, start the browser again.

    Example on the CLI:

     % restart-browsers --restart-firefox

    To customize command:

     % restart-browsers --start-firefox --firefox-cmd 'firefox -P myprofile'

    when starting each browser, console output will be captured and returned
    in function metadata. Will wait for 2/5/10 seconds and check if the
    browsers have been started. If all browsers can't be started, will
    return 500; otherwise will return 200 but report the browsers that
    failed to start to the STDERR.

    This function is not exported.

    This function supports dry-run operation.

    Arguments ('*' denotes required arguments):

    *   chrome_cmd => *array[str]|str* (default: "google-chrome")

        (No description)

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

        (No description)

    *   opera_cmd => *array[str]|str* (default: "opera")

        (No description)

    *   quiet => *true*

        (No description)

    *   restart_brave => *bool*

        (No description)

    *   restart_chrome => *bool*

        (No description)

    *   restart_firefox => *bool*

        (No description)

    *   restart_opera => *bool*

        (No description)

    *   restart_vivaldi => *bool*

        (No description)

    *   vivaldi_cmd => *array[str]|str* (default: "vivaldi")

        (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_browsers
    Usage:

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

    Start browsers.

    For each of the requested browser, check whether browser processes (that
    run as the current user) exist and if not then start the browser. If
    browser processes exist, even if all are paused, then no new instance of
    the browser will be started.

    when starting each browser, console output will be captured and returned
    in function metadata. Will wait for 2/5/10 seconds and check if the
    browsers have been started. If all browsers can't be started, will
    return 500; otherwise will return 200 but report the browsers that
    failed to start to the STDERR.

    Example on the CLI:

     % start-browsers --start-firefox

    To customize command to use to start:

     % start-browsers --start-firefox --firefox-cmd 'firefox -P myprofile'

    This function is not exported.

    This function supports dry-run operation.

    Arguments ('*' denotes required arguments):

    *   chrome_cmd => *array[str]|str* (default: "google-chrome")

        (No description)

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

        (No description)

    *   opera_cmd => *array[str]|str* (default: "opera")

        (No description)

    *   quiet => *true*

        (No description)

    *   start_brave => *bool*

        (No description)

    *   start_chrome => *bool*

        (No description)

    *   start_firefox => *bool*

        (No description)

    *   start_opera => *bool*

        (No description)

    *   start_vivaldi => *bool*

        (No description)

    *   vivaldi_cmd => *array[str]|str* (default: "vivaldi")

        (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_browsers
    Usage:

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

    Terminate browsers (by default with -KILL).

    This function is not exported.

    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_browsers
    Usage:

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

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

    See also the "pause_browsers" and the "pause_and_unpause_browsers"
    routines.

    This function is not exported.

    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-BrowserUtils>.

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

SEE ALSO
    Utilities using this distribution: App::FirefoxUtils, App::ChromeUtils,
    App::OperaUtils, App::VivaldiUtils

    App::BrowserOpenUtils

AUTHOR
    perlancar <perlancar@cpan.org>

CONTRIBUTOR
    Steven Haryanto <stevenharyanto@gmail.com>

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) 2023, 2022, 2021, 2020, 2019 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-BrowserUtils>

    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.