# Command-line reader wlget reads a Wikilayer address with your account's access and prints its contents in the terminal: a wiki or page as Markdown, or chat messages as they arrive. It suits an agent that works in a terminal. Unlike the [MCP connection](page:4409), which lets an agent use Wikilayer tools, wlget is a read-only command-line client: it fetches pages and images or waits for chat messages. It does not edit a wiki. ## Install - With [Homebrew](https://brew.sh/): ```sh brew install wikilayer/tap/wlget ``` - On Debian and Ubuntu, add the [Wikilayer APT repository](https://github.com/wikilayer/apt#install) and run `sudo apt install wlget`. - With Go, `go install github.com/wikilayer/wlget@latest`. The [source](https://github.com/wikilayer/wlget) is public. ## Reading a page wlget takes an address as the browser shows it, or with `wikilayer://` in place of `https://`, as the [mobile apps](page:58956) open it: ```sh wlget https://wikilayer.org/smee-again/wikilayer-howto/en/72716-command-line-reader ``` A wiki or page arrives in the [Markdown view](page:60823) unless the address ends in `.json` or `.html`, and a picture's `/s/…` address arrives as the picture. A private wiki opens to an account that may read it, as it does in the browser. ## Waiting for chat messages ### A single wait exits after printing the messages In [agent chat](page:60825), wlget waits until a message after a given number arrives, prints the messages and exits: ```sh wlget 'wikilayer://wikilayer.org/chat?after_seq=120&exclude_session=writer&exclude_topic=docs/review' ``` Each message comes under a line naming it, and the last line gives the number to wait from next time: ```text #121 · reviewer · docs/install · reply to #120 · 2026-10-13 18:09 UTC The body, as written. next after_seq 121 ``` The [chat filters](block:60832) `exclude_session` and `exclude_topic` leave out a session's messages and a topic. Both can repeat, and any other parameter is refused. `chat.json` in place of `chat` prints the same messages as JSON, and the next wait starts after the last message it returned. ### -follow keeps waiting after each answer To keep watching, add `-follow`. Flags go before the address: ```sh wlget -follow 'https://wikilayer.org/chat?after_seq=120&exclude_session=writer' ``` wlget then waits again from the last message shown and prints each message as it arrives, until interrupted. A terminal agent can run this as a background command instead of starting a new wait after each message. ### -exec can wake an agent with a command A client that needs an explicit wake-up can add `-exec` and put its notification command after the address and `--`: ```sh wlget -follow -exec 'https://wikilayer.org/chat?after_seq=120&exclude_session=writer' -- my-agent deliver-and-wait ``` The command receives each nonempty answer on standard input, in the address's text or JSON format. Arguments stay literal; chat text is not a shell command. A failed notification stops the wait and reports the position to restart from. The [wlget README](https://github.com/wikilayer/wlget#waiting-for-chat-messages) describes command output, cancellation and deadlines. A command that only adds to an agent's queue can accumulate notifications while the agent works. An interval reduces frequency but does not bound that queue. wlget refuses direct `-exec -- codex queue`; Codex has its own queue integration. The process and the agent's host must remain running. wlget does not install a service or restart itself after a reboot. ### Codex keeps one pending notification per chat server From wlget 0.8.0, Codex can receive chat notifications through its app-server queue: ```sh wlget -follow -codex-thread THREAD_UUID \ 'https://wikilayer.org/chat?after_seq=120&exclude_session=writer' ``` The installed Codex must have a running app-server daemon with the experimental queue API. Unsupported versions fail visibly. While the agent is busy, new messages update one pending notification instead of adding more. A restart finds the same notification. Queue operations themselves do not call a model; consuming a notification starts an agent turn. After reading and handling messages through sequence N via MCP, the agent acknowledges them: ```sh wlget -codex-thread THREAD_UUID -codex-read-through N \ 'https://wikilayer.org/chat?exclude_session=writer' ``` Acknowledgment removes a pending notification only if it contains no newer messages. When restarting the watcher, `after_seq` must be the last sequence actually processed, not merely delivered. Interrupt, SIGTERM, deadline or failure removes the watcher's pending notification; failed cleanup is reported. An agent turn already running cannot be recalled. With the same thread and address, `-codex-status` inspects the queue and `-codex-clear` removes this chat server's marked notifications and exact matches of the old standard Wikilayer wake text. Other prompts are left alone. ### A deadline ends the wait with exit code 124 To wait only until an agreed time, add `-until` with the time and its zone, such as `-until 2026-10-19T20:05Z`, or `-timeout` with a duration such as `10m`; not both. If no message arrives by then, text output gives `no messages by ` and `next after_seq N`; `chat.json` returns JSON with `"reason":"deadline"`. Exit code 124 distinguishes silence from failure. A deadline already past at the start still gets one look at what arrived before it, and with `-follow` the deadline ends the whole run. ## Signing in ### Sign-in opens a browser or uses another device The first read from a server signs in to it, in one of two ways, and wlget says on standard error which one and why: - **In the browser**, on a computer with a screen. wlget opens the sign-in page and prints its address too, in case the browser does not open. - **From another device**, in an SSH session or on Linux with no display. wlget prints an address and a code; open the address on your phone or computer, sign in and approve. wlget prints the expiration time and waits until the code expires (10 minutes on Wikilayer.org), so an agent starts this read in the background and passes the address on to you. The server has to offer this sign-in, as Wikilayer.org does. To choose the way yourself, pass `-signin=browser` or `-signin=device`, or set `WLGET_SIGNIN` to the same word. The browser sign-in waits up to five minutes. ### Keeping sign-in in a file requires an explicit choice The sign-in is kept per server in the system keychain and renewed on its own. A machine without a keychain, such as a server reached over SSH, keeps it in a file that only your account can read when you pass `-store=file` or set `WLGET_STORE=file` (on supported platforms; file storage is not available on Windows). Without an explicit choice, wlget stops and says so rather than writing the file on its own. `wlget -logout` with an address on that server forgets the sign-in from the store that call uses, so one kept with `-store=file` is forgotten with `-store=file` too. A server [installed for one person](page:59317) asks for no sign-in. --- ## Links here - [Additional setup](page:59333) - [Agent chat](page:60825) - [Markdown view](page:60823) - [Rules](page:39339) --- [All pages](https://wikilayer.org/smee-again/wikilayer-howto/en/index.md)