mindvest-atlas 0.50.0 → 0.50.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.50.0",
+  "version": "0.50.2",
   "description": "Atlas CLI \u2014 OAuth login, tool calls, and live alert/flow streaming for the Atlas trading API",
   "type": "module",
   "bin": {

package/src/commands/computer-use.js

@@ -99,6 +99,16 @@ const OPS = {
   // command beats a key chord, which goes wherever the focus is and reports
   // success either way.
   windows: ['windows', 0],
+  // A console Windows put on top of everything is machinery, not the desk.
+  'hide-consoles': ['hide_consoles', 0],
+  // ── A JOB THAT IS MOSTLY WAITING ──────────────────────────────────────
+  watch: ['watch', 1],
+  // ── ONE CALL FOR WHAT USED TO BE FOUR ─────────────────────────────────
+  'scroll-x': ['scroll_x', 1],
+  'shift-scroll': ['shift_scroll', 1],
+  swipe: ['swipe', 4],
+  zoom: ['zoom', 1],
+  page: ['page', 1],
   minimize: ['minimize_window', 1],
   maximize: ['maximize_window', 1],
   restore: ['restore_window', 1],
@@ -114,7 +124,8 @@ const OPS = {
 // that takes numbers in one runtime and strings in the other is a verb nobody
 // can rely on.
 const NUMERIC = new Set(['use-screen', 'click', 'double-click', 'right-click',
-  'middle-click', 'triple-click', 'move', 'drag', 'scroll', 'wait', 'region']);
+  'middle-click', 'triple-click', 'move', 'drag', 'scroll', 'wait', 'region',
+  'scroll-x', 'shift-scroll', 'swipe', 'zoom']);
 
 /** This shell's holding id, made once and remembered. Shared with `atlas run`
  *  so everything typed at one prompt lands in ONE session: the log reads as a
@@ -198,20 +209,34 @@ const NEEDED = [['pyautogui', 'pyautogui'], ['mss', 'mss'], ['Pillow', 'PIL']];
  * Best effort and quiet: a machine with no network or no pip is one that runs
  * without it, and every call site already says what it cannot do.
  */
+/**
+ * NOTHING THIS DOES MAY PUT A WINDOW ON THE SCREEN.
+ *
+ * On Windows a console program started by a process with no console of its own
+ * gets a NEW one, drawn on top of everything. Every action here runs python, so
+ * a black console box appeared over the desktop at exactly the moment the screen
+ * was photographed — and the agent, looking at its own picture, then spent the
+ * run trying to work out what the black window was (owner, 2026-09-06: "the AI
+ * complains of a black console every time; that console is just the popup taking
+ * screenshots"). A picture of the desktop must not contain the machinery that
+ * took it.
+ */
+const HIDDEN = { windowsHide: true };
+
 export function ensureDeps(python, cwd, env) {
   const check = `import ${NEEDED.map(([, mod]) => mod).join(', ')}`;
   const has = () => spawnSync(python[0], [...python.slice(1), '-c', check],
-    { cwd, env, stdio: 'ignore' }).status === 0;
+    { cwd, env, stdio: 'ignore', ...HIDDEN }).status === 0;
   if (has()) return true;
   println(color.dim('  Getting this computer ready (one time)…'));
   // --user is wrong inside a venv and right outside one, so ask the interpreter
   // which it is in rather than guessing.
   const inVenv = spawnSync(python[0],
     [...python.slice(1), '-c', 'import sys; sys.exit(0 if sys.prefix != sys.base_prefix else 1)'],
-    { cwd, env, stdio: 'ignore' }).status === 0;
+    { cwd, env, stdio: 'ignore', ...HIDDEN }).status === 0;
   const args = ['-m', 'pip', 'install', '--quiet', ...(inVenv ? [] : ['--user'])];
   spawnSync(python[0], [...python.slice(1), ...args, ...NEEDED.map(([name]) => name)],
-    { cwd, env, stdio: 'ignore', timeout: 300000 });
+    { cwd, env, stdio: 'ignore', timeout: 300000, ...HIDDEN });
   return has();
 }
 
@@ -239,7 +264,7 @@ export function runInProject(job, code, root) {
   env.ATLAS_COMPUTER_PID = '0';
   env.PYTHONPATH = [dir, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter);
   const out = spawnSync(python[0], [...python.slice(1), '-c', code], {
-    cwd: dir, env, stdio: 'inherit',
+    cwd: dir, env, stdio: 'inherit', ...HIDDEN,
   });
   if (out.error) {
     eprintln(color.red('This computer has no Python, and using it needs one.'));

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.50.0';
+export const VERSION = '0.50.2';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';

package/src/helpers/atlas_env.py

@@ -1390,6 +1390,11 @@ def screen(path=None, grid=None):
 
     def take():
         import hashlib
+        # NOTHING OF OURS IN THE PICTURE. A console that Windows put on top a
+        # moment ago is machinery, not the desk, and a run that photographs one
+        # spends its time on it instead of on the work. Swept before the shutter,
+        # so no picture can contain one.
+        hide_consoles()
         img, raw = _grab(m)
         digest = hashlib.md5(raw).hexdigest() if raw is not None else None
         seen = _last_look()
@@ -1725,6 +1730,11 @@ def do(*steps, **kw):
     """
     settle = float(kw.get("settle", 1.2))
     look = kw.get("look", True)
+    # AND NOTHING OF OURS IN FRONT OF IT. A console Windows put on top has the
+    # KEYBOARD, so a run of steps types its password into a black box instead of
+    # into the form it was aiming at, and every shortcut goes nowhere. Swept
+    # before the first step rather than discovered after the last.
+    hide_consoles()
     # What it looked like before any of this, so the wait afterwards can tell
     # "nothing has happened yet" from "it happened and is done". Only worth
     # measuring when there is going to be a wait: settle=0 says do not wait, and
@@ -1962,6 +1972,111 @@ def _one_window(title):
     return got
 
 
+#: A CONSOLE NOBODY NAMED, recognised by SHAPE rather than by a list of names.
+#:
+#: The title of a console window is the command line of the program in it until
+#: something sets one. So "C:\...\python3.11.exe" is machinery, and so is
+#: "C:\...\Atlas Remote Control.exe" — which a list of interpreter names would
+#: have walked straight past, and that one was the window sitting over the
+#: owner's chart (owner, 2026-09-06: "screen for any console interpreter and
+#: let's stick with background processes for all of it").
+#:
+#: A window somebody is WORKING in has a title about their work: "trading notes
+#: - bash" does not end in .exe and is left alone. That is the whole boundary,
+#: and it is deliberately the conservative side of the line.
+_EXE_TITLE = __import__("re").compile(r"\.exe$", __import__("re").I)
+
+
+def _looks_like_a_console(title):
+    """True for a window whose title is just the program running in it."""
+    name = str(title or "").strip()
+    if not name:
+        return False
+    # `"C:\path\codex.exe" app-server` — a quoted program plus its arguments.
+    if name.startswith('"') and '"' in name[1:]:
+        return bool(_EXE_TITLE.search(name[1:name.index('"', 1)]))
+    # Windows Terminal titles a tab "<something> - powershell.exe".
+    return bool(_EXE_TITLE.search(name) or _EXE_TITLE.search(name.rsplit(" - ", 1)[-1].strip()))
+
+
+def _put_out_of_sight(win):
+    """Hide it outright where the platform allows, and minimise where it does not.
+
+    HIDDEN, NOT MINIMISED. A minimised console is still a window: it holds a
+    taskbar button, it can be restored by a stray click, and it flashes on its
+    way down — and the ask was for these to be BACKGROUND PROCESSES, which is
+    what a program with no window on screen actually is. ShowWindow(SW_HIDE)
+    takes it off the screen entirely without touching the process, so whatever is
+    running in it carries on with its output still going where it always went.
+    """
+    try:
+        import ctypes
+        handle = getattr(win, "_hWnd", None)
+        if handle and os.name == "nt":
+            ctypes.windll.user32.ShowWindow(int(handle), 0)   # SW_HIDE
+            return True
+    except Exception:
+        pass
+    win.minimize()
+    return True
+
+
+def hide_consoles():
+    """Put the machinery's own console windows out of the picture.
+
+    WHY THIS EXISTS AT ALL. Running anything on Windows can allocate a console,
+    and Windows draws a new one on top of everything and gives it the keyboard.
+    It should not happen — every spawn here asks for no window — but with
+    Windows Terminal set as the default console host that request is not always
+    honoured, and the result is a black box sitting over the person's charts,
+    cascading down-right each time it is focused, eating the keystrokes meant
+    for the app being driven.
+
+    An agent then photographs it and, quite reasonably, spends the run trying to
+    work out what it is (owner, 2026-09-06: "can we make bash, powershell or any
+    terminal invisible or minimized so the agent does not need to see this ...
+    the best is to auto minimise or auto layer to the back").
+
+    IT IS HIDDEN, NEVER CLOSED. That window is the process running the commands:
+    closing it ends the session issuing them. Hiding takes it off the screen
+    without touching what is inside, and hands the keyboard back to whatever was
+    in front, which is the other half of the damage it does.
+
+    Hidden rather than minimised, because a minimised console is still a window
+    — a taskbar button, one stray click from being back, and a flash on the way
+    down. A background process is one with no window on screen.
+
+    Identified by TITLE, and only the ones nobody named: a console's title is
+    the path of the program in it until something sets one, so
+    a path ending in python3.11.exe is machinery, and "trading notes - bash" is
+    somebody's work and is left alone.
+
+    Quiet and best effort: a machine that cannot list its windows is one this
+    does nothing on.
+    """
+    hidden = []
+    try:
+        wins = _all_windows()
+    except Exception:
+        return hidden
+    for w in wins:
+        title = str(getattr(w, "title", "") or "")
+        if not _looks_like_a_console(title):
+            continue
+        try:
+            # ALREADY GONE IS ALREADY DONE. The test is whether it is on the
+            # screen, not whether it is minimised: a minimised console still has
+            # a taskbar button and is one click from being back, so it is still
+            # something to put away.
+            if getattr(w, "visible", True) is False:
+                continue
+            _put_out_of_sight(w)
+            hidden.append(title[:120])
+        except Exception:
+            continue
+    return hidden
+
+
 def windows(title=""):
     """Every window that is open, with where it is and what state it is in.
 
@@ -2122,6 +2237,357 @@ def scan_page(x=None, y=None, most=10, amount=None, grid=None):
     return _do("scan_page", go, {"x": x, "y": y, "step": step})
 
 
+#: What a round of watching may wait, in minutes. A model asked how long to
+#: leave it will occasionally say 0 (a busy loop, billed per turn) or 600 (an
+#: afternoon in which anything could happen). Its judgement inside these bounds
+#: is better than a fixed interval; outside them it is a mistake, not a choice.
+_WAIT_FLOOR_MIN = 0.5
+_WAIT_CEILING_MIN = 120.0
+
+
+def _next_wait(answer, fallback):
+    """How long the model asked to wait, in minutes, or `fallback` if it did not.
+
+    Pass fallback=None to tell the two apart: "it asked for this" and "it said
+    nothing" lead to different behaviour, and a default that quietly stands in
+    for silence is how a dynamic interval becomes a fixed one without anybody
+    noticing.
+
+    Read from a `NEXT: <minutes>` line rather than by parsing prose. A model
+    writing a paragraph will mention several numbers and the last thing you want
+    is to have picked one of them out of a sentence.
+    """
+    import re as _re
+    hit = None
+    for m in _re.finditer(r"^\s*NEXT\s*:\s*([0-9]+(?:\.[0-9]+)?)", str(answer or ""),
+                          _re.I | _re.M):
+        hit = m.group(1)
+    if hit is None:
+        return fallback
+    try:
+        want = float(hit)
+    except ValueError:
+        return fallback
+    return max(_WAIT_FLOOR_MIN, min(_WAIT_CEILING_MIN, want))
+
+
+def _watch_done(answer):
+    """The model saying it is finished, on a line of its own."""
+    import re as _re
+    return bool(_re.search(r"^\s*DONE\s*$", str(answer or ""), _re.I | _re.M))
+
+
+def _still_mine():
+    """Are we still the ones holding the computer?
+
+    STOP DELETES THE CLAIM. That is how Atlas ends a run, and it is a signal any
+    loop can read: no claim, or somebody else's, means this run is over. A long
+    sleep that does not check it is a run that carries on for another twenty
+    minutes after Stop, and then acts (owner, 2026-09-06: "if I click stop, the
+    entire thing stops, no lingering data or wait").
+    """
+    held = _claim_holder()
+    if not held:
+        return False
+    mine = os.environ.get("ATLAS_COMPUTER_SESSION") or ""
+    return not mine or str(held.get("session") or "") == mine
+
+
+def _sleep_or_stop(seconds, slice_s=1.0):
+    """Wait, in slices, and give up the moment the run is stopped.
+
+    Returns False when it was stopped, True when it slept the whole way. One
+    long sleep cannot be interrupted, so it is many short ones — the cost is a
+    file read a second, which next to a model call is nothing.
+    """
+    import time as _time
+    left = max(0.0, float(seconds))
+    while left > 0:
+        if not _still_mine():
+            return False
+        nap = min(slice_s, left)
+        _time.sleep(nap)
+        left -= nap
+    return _still_mine()
+
+
+def watch(instruction, every=5, most=200, hours=8, look=True):
+    """Watch the screen and act when it is time. Runs until it is done.
+
+    THE SHAPE OF A JOB THAT IS MOSTLY WAITING (owner, 2026-09-06: "watch this
+    market, wait until you see a setup, when you see it put a trade, keep
+    watching, check every 5 minutes"). Most of what somebody wants from a
+    computer that can see is not a task with a beginning and an end; it is a
+    watch. Written as a script it is a loop nobody gets right: too fast and it
+    burns a model call a second, too slow and it misses the thing.
+
+        watch("Watch the SPY 5-minute chart. When price breaks above the "
+              "opening range high on rising volume, buy 1 call and say so.")
+
+    Each round: it looks, then asks YOUR model what it sees and what to do. The
+    model has the same computer this does, so when it decides to act it acts —
+    there is no separate step where something else carries out its decision.
+
+    THE WAIT IS THE MODEL'S TO CHOOSE, and that is the point. A fixed interval is
+    wrong in both directions all day: nothing is happening at lunch and
+    everything is happening at the open. So each round ends by asking how long to
+    leave it, and the answer sets the next sleep — "quiet, look again in 20" or
+    "this is setting up, 2 minutes" (owner: "each loop wait can update, so
+    dynamic based on what the agent said"). `every` is only the FIRST wait and
+    the fallback when it does not say.
+
+    IT HOLDS THE COMPUTER THE WHOLE TIME. There is one mouse, and something that
+    may need to act at any moment cannot hand it back between looks. Nothing else
+    can drive while this runs, which is a real cost and the reason for `hours`.
+
+    IT COSTS A MODEL CALL PER ROUND. That is what the interval is really
+    choosing, and why a model that says "nothing is happening, look again in an
+    hour" is doing its job rather than being lazy.
+
+    Ends when the model writes DONE on a line by itself, when `most` rounds have
+    passed, or when `hours` have. Pressing Stop ends it like anything else.
+    """
+    import time as _time
+    began = _time.time()
+    deadline = began + max(0.0, float(hours)) * 3600.0
+    wait_min = max(_WAIT_FLOOR_MIN, min(_WAIT_CEILING_MIN, float(every)))
+    rounds = 0
+    seen = []
+    waits = []
+    quiet = 0
+    changed = None
+    note("watching: %s" % str(instruction)[:160])
+    stopped = False
+    done = False
+    try:
+        while rounds < int(most) and _time.time() < deadline:
+            # STOP MEANS STOPPED, AT EVERY POINT IT COULD MEAN ANYTHING ELSE.
+            # Atlas ends a run by deleting the claim; a loop that does not read
+            # it carries on for another twenty minutes and then ACTS (owner,
+            # 2026-09-06: "if I click stop, the entire thing stops, no lingering
+            # data or wait").
+            if not _still_mine():
+                stopped = True
+                break
+            rounds += 1
+            shot = None
+            if look:
+                try:
+                    got = screen()
+                    shot = got if isinstance(got, str) else got.get("path")
+                    # Whether anything moved, which decides the backoff when the
+                    # model does not choose.
+                    changed = _screen_changed(shot)
+                except Exception as err:
+                    # A look that fails is not a reason to stop watching; the
+                    # model is told, and decides whether that matters.
+                    shot = None
+                    seen.append({"round": rounds, "error": str(err)})
+            asked = (
+                "%s\n\n"
+                "You are WATCHING, not running a task to completion. This is round %d.\n"
+                "%s\n"
+                "Decide whether anything has changed that matters, and if it is time "
+                "to act, ACT NOW using the computer yourself - you have the same "
+                "`atlas computer-use` this does.\n\n"
+                "End your reply with exactly two things on their own lines:\n"
+                "  NEXT: <minutes until the next look>\n"
+                "  DONE   (only if there is nothing left to watch for)\n"
+                "CHOOSE THE INTERVAL YOURSELF and change it as things change: two or "
+                "three minutes when something is developing, fifteen or sixty when it "
+                "is quiet. The same number every round is a fixed poll, which is the "
+                "one thing this is not. A model call is spent every round."
+                % (instruction, rounds,
+                   ("The screen right now: %s" % shot) if shot
+                   else "The screen could not be photographed this round.")
+            )
+            try:
+                answer = ask(asked)
+            except Exception as err:
+                answer = ""
+                seen.append({"round": rounds, "error": str(err)})
+            if answer:
+                note(str(answer).strip()[:400])
+                seen.append({"round": rounds, "said": str(answer)[:2000]})
+            if _watch_done(answer):
+                note("done watching after %d rounds" % rounds)
+                done = True
+                break
+            # THE MODEL'S JUDGEMENT WINS WHENEVER IT GIVES ONE.
+            asked_for = _next_wait(answer, None)
+            if asked_for is not None:
+                wait_min = asked_for
+                quiet = 0
+            else:
+                # AND WHEN IT DOES NOT, THE LOOP BACKS OFF BY ITSELF.
+                #
+                # The whole point is that the interval MOVES; a model that
+                # answers nothing round after round has quietly turned this back
+                # into a fixed poll and nothing would say so. Silence is not
+                # agreement: with the screen unchanged too, the wait grows.
+                # Something happening resets it.
+                #
+                # It only ever fills a gap the model left. An explicit NEXT is
+                # obeyed, including a short one every round, because a model
+                # watching something develop is right to keep looking.
+                if changed is False:
+                    quiet += 1
+                    if quiet >= 2:
+                        grown = min(_WAIT_CEILING_MIN, wait_min * 1.5)
+                        if grown > wait_min:
+                            note("nothing is changing and no interval was given - "
+                                 "waiting %d minutes instead of %d"
+                                 % (round(grown), round(wait_min)))
+                        wait_min = grown
+                else:
+                    quiet = 0
+            waits.append(wait_min)
+            # NO SLEEP AFTER THE LAST ROUND. It is over: waiting five more
+            # minutes to discover that is five minutes holding the computer for
+            # nothing.
+            if rounds >= int(most):
+                break
+            left = deadline - _time.time()
+            if left <= 0:
+                break
+            # SLICED, so Stop lands in a second rather than at the end of a
+            # twenty-minute wait.
+            if not _sleep_or_stop(min(wait_min * 60.0, left)):
+                stopped = True
+                break
+    finally:
+        # WHATEVER HAPPENED, LET GO. A watch holds the computer for hours, so a
+        # run that ends any other way than tidily — an error, Stop, the ceiling —
+        # would leave the one mouse claimed and nothing else able to drive.
+        try:
+            release_computer()
+        except Exception:
+            pass
+    note("%s after %d rounds" % ("stopped" if stopped else
+                                 "finished" if done else "ran out", rounds))
+    # `waits` is every interval it used and `varied` says whether they moved at
+    # all - so "the model just echoes one number back" is something anybody can
+    # SEE rather than suspect.
+    return {"rounds": rounds, "done": done, "stopped": stopped, "seen": seen,
+            "waits": waits, "varied": len(set(waits)) > 1}
+
+
+def scroll_x(amount, x=None, y=None):
+    """Scroll SIDEWAYS. Positive goes right, negative left.
+
+    NOT EVERYWHERE, AND SAID RATHER THAN SILENTLY IGNORED. Windows has no
+    horizontal wheel at the API this uses; macOS and Linux do. Where it is
+    missing, the ways that DO work on every platform are named, because a wide
+    table nobody can reach sideways is a wall (owner, 2026-09-06: "add left
+    scrolling, right scrolling").
+
+    On Windows: shift+wheel is what applications themselves map to sideways,
+    which is what shift_scroll() does — or drag the scrollbar, which always
+    works because it is just a thing on the screen.
+    """
+    def go():
+        g = _gui()
+        if x is not None and y is not None:
+            g.moveTo(int(x), int(y))
+        if not hasattr(g, "hscroll") or os_name() == "windows":
+            raise RuntimeError(
+                "This computer has no sideways wheel. Use shift_scroll(%d) — "
+                "applications map shift+wheel to sideways — or drag the "
+                "scrollbar, which works anywhere." % int(amount)
+            )
+        g.hscroll(int(amount))
+    return _do("scroll_x", go, {"amount": amount, "x": x, "y": y})
+
+
+def shift_scroll(amount, x=None, y=None):
+    """Sideways the way applications actually do it: shift and the wheel.
+
+    WORKS ON ALL THREE, which the real horizontal wheel does not. Nearly every
+    program that scrolls sideways binds this, so it is the first thing to try
+    rather than the fallback. Positive is right, negative is left, same as
+    scroll_x.
+    """
+    def go():
+        g = _gui()
+        if x is not None and y is not None:
+            g.moveTo(int(x), int(y))
+        g.keyDown("shift")
+        try:
+            # The wheel's own sign is inverted under shift in most applications:
+            # a positive (up) wheel with shift held goes LEFT. Negated here so
+            # that positive means right, as it says on the tin.
+            g.scroll(-int(amount))
+        finally:
+            g.keyUp("shift")
+    return _do("shift_scroll", go, {"amount": amount, "x": x, "y": y})
+
+
+def swipe(x, y, dx=0, dy=0, seconds=0.35):
+    """Drag from a point BY an amount — a flick, a pan, a slider.
+
+    ONE CALL FOR SOMETHING THAT WAS FOUR. Panning a chart or moving a slider was
+    move, mouse_down, move, mouse_up, and four calls is four round trips and four
+    chances to leave the button held down if one of them is refused. The button
+    is released in a `finally`, so a refusal in the middle does not leave the
+    mouse stuck.
+
+        swipe(*middle, dx=-400)      # drag the chart left by 400
+    """
+    def go():
+        g = _gui()
+        g.moveTo(int(x), int(y))
+        g.mouseDown()
+        try:
+            g.dragTo(int(x) + int(dx), int(y) + int(dy), duration=max(0.0, float(seconds)))
+        finally:
+            g.mouseUp()
+    return _do("swipe", go, {"x": x, "y": y, "dx": dx, "dy": dy},
+               points=((x, y), (int(x) + int(dx), int(y) + int(dy))))
+
+
+def zoom(steps=1, x=None, y=None):
+    """Zoom in (positive) or out (negative), the way every platform does it.
+
+    ctrl and the wheel on Windows and Linux, command and the wheel on a Mac.
+    One call rather than a chord the agent has to remember differently per
+    machine — and getting that wrong is a keystroke into whatever had focus.
+    """
+    def go():
+        import sys as _sys
+        g = _gui()
+        if x is not None and y is not None:
+            g.moveTo(int(x), int(y))
+        holder = "command" if _sys.platform == "darwin" else "ctrl"
+        g.keyDown(holder)
+        try:
+            g.scroll(int(steps))
+        finally:
+            g.keyUp(holder)
+    return _do("zoom", go, {"steps": steps, "x": x, "y": y})
+
+
+def page(way="down", times=1):
+    """Page down or up, the whole screenful, without a wheel.
+
+    What a keyboard does and a wheel approximates. `way` is "down", "up",
+    "top" or "bottom" — the last two are one keystroke to either end, which is
+    the fastest way to the bottom of a long page by a distance.
+    """
+    keys = {"down": "pagedown", "up": "pageup", "top": "home", "bottom": "end"}
+    which = keys.get(str(way).lower())
+    if not which:
+        raise RuntimeError('page() takes "down", "up", "top" or "bottom", not "%s".' % way)
+
+    def go():
+        g = _gui()
+        for _ in range(max(1, int(times))):
+            if which in ("home", "end"):
+                g.hotkey("ctrl", which)
+            else:
+                g.press(which)
+    return _do("page", go, {"way": str(way), "times": times})
+
+
 def wait(ms):
     """Wait, and say so. A pause nobody recorded looks like a hang in a replay.