🔭Scout v0.1.0

Added

• VisibleUI Scout has a new app icon, a stone watchtower with a glowing lantern on a gold hexagonal badge. The badge sits on a dark teal rounded square, with two green banners and an emerald over the tower door. Every other size, from the favicon to the tray app’s Windows and macOS icons, is generated from packages/web/public/icon.svg by node tools/make-icons.mjs. The web page now links a web app manifest, so a browser can offer to install Scout as an app. The tray app’s executable, installer, and shortcuts use it too, and the status icon in the notification area is now a small gold-and-amber watchtower beside the same green, amber, red, or grey status marker.
• VisibleUI A Resources page shows how busy each machine is. It sits beside Services in the top navigation, with one card per machine that gives its operating system, the age of the reading, and a one-line summary. Each card has rows for Processor, Memory, each disk, Video memory and Graphics for each NVIDIA card, and Network, and each row shows a bar, a number, and, except for disks and video memory, a half-hour chart. A row turns amber and says High at 70 percent, and turns red with a striped bar and says Very high at 85 percent. Selecting Processor or Memory lists the five processes using the most of it on that machine, and a process that belongs to a running service or an open listener in the catalog shows that name instead of its process name.
• VisibleServices The hub reads processor, memory, disk, graphics, and network use from every machine. It uses the connection Scout already has for each machine, locally on the hub machine and over ssh for the others, and runs one fixed read-only script per operating system. Readings arrive every 60 seconds, or every 10 seconds while the Resources page is open. A machine that cannot be read keeps its last reading, which is marked Stale after 150 seconds, and the other machines carry on. --no-meters turns metering off.
• VisibleUI Scout sends you a notice when a disk is nearly full, memory is under pressure, or video memory is nearly used up. A notice goes out once a meter has stayed at or over its threshold for a set number of minutes: 90 percent for 5 minutes for each disk, 92 percent for 10 minutes for each machine’s memory, and 95 percent for 10 minutes for each graphics card’s video memory. Each episode sends one notice through the same desktop notification and Discord webhook as outage notices, and one “back to normal” notice follows once the meter falls 5 points under the threshold. The Alerts section on the Resources page turns each rule on or off and changes its percentage and minutes, and the same settings are kept in .scout-data/meter-alerts.json on the hub machine.
• VisibleUI The tray panel shows how busy the selected machine is. A strip under the machine tabs has rows for Processor, Memory, the busiest disk, and Video memory, each with a bar and a percentage. A row turns amber and says High at 70 percent, and turns red and says Very high at 85 percent, the same as on the Resources page, and a reading older than 150 seconds is dimmed. The tray icon’s tooltip also lists each machine that has a reading, for example “Eru 12% CPU 38% RAM 20% VRAM”, with the VRAM figure only on machines that have a graphics card.
• VisibleUI The tray panel starts when you sign in and starts again after a crash. The installed app registers itself each time it starts: a per-user scheduled task named “Scout Tray” on Windows, and a LaunchAgent on macOS. A development build registers nothing. “Start at login” on the tray icon’s right-click menu is on by default and turns this off or back on. Quit asks for confirmation first, and after Quit Scout the tray stays closed until the next time you sign in.
• VisibleServices You can disable and enable launchd jobs and scheduled tasks from Scout. Disable stops the job and keeps it from running again until you enable it, and both actions go through the same plan, confirmation, and audit log as start, stop, and restart.
• VisibleInventory Scout scans your machines and lists the software on each one. It reads Windows (registry, winget, Store apps, WSL, Docker Sandboxes), macOS (apps, Homebrew, casks, pkgutil, launchd), npm, pipx, and uv tools, Go and local binaries, language runtimes, container images, and dpkg packages on Linux. Remote machines are read over ssh, and a scan never starts a program or a guest.
• VisibleUI A page on the hub machine shows the whole catalog. It has Catalog, Updates, Review, Jobs, and Services views with live search, filters you can save, and a detail panel for each install. The Review view lets you confirm or reject installs that Scout thinks are the same program.
• VisibleResearch Scout finds the newest version of each install. It asks Homebrew, npm, PyPI, GitHub releases, the Go module proxy, crates.io, Sparkle appcasts, winget, and the Store, and shows end-of-life dates from endoflife.date as notes.
• VisibleUpdates You can update installs from the page. Scout shows the exact winget, Store, brew, cask, npm, pipx, or uv command, waits for you to confirm, and then runs a check, the update, and a verify step for one job at a time on each machine. The Updates list is sorted by a priority score by default.
• VisibleUpdates Updates that would break other software are refused. If an update would break a runtime another program needs, Scout refuses it, and smaller risks ask for a second confirmation. Version pins in your project files show up as notes.
• VisibleUpdates Apps with no package manager can get their installer downloaded. Scout saves it to that machine’s Downloads folder after checking its size and checksum, and leaves running it to you.
• VisibleServices The Services view shows what is running and listening on each machine. It lists open ports, Windows services, scheduled tasks, and launchd jobs, marks each as essential, optional, or third-party, and gives each a short description you can edit.
• VisibleServices You can start, stop, and restart services from Scout. Each action shows a plan first, needs a one-time confirmation, and is logged. Scout will not stop anything on its protected list, such as ssh, remote access, the tunnel, or Scout itself, and it gives uninstall steps as text only.
• VisibleServices A Windows hub machine can start your own projects. Scout finds package scripts, launch configurations, and compose files in your project folders and runs each one only after you approve its exact command. Stacks start several of them in order and wait for each port to open.
• VisibleServices Alerts tell you when something changes. They cover new listeners and background jobs, stopped services, sites that are down, ports that became reachable from more places, failing health checks, certificates that expire within 14 days, crash loops, and port clashes with your ports registry. You can acknowledge or mute each one.
• VisibleServices Installs, services, and listeners carry provenance flags. Odd location marks something installed in or running from a temp folder, a Downloads or Desktop folder, the shared Public folder, or the Recycle Bin. No publisher marks a Windows uninstall entry that names none, Not signed marks a Store app package with no signature, and Mine marks what belongs to your own projects. Each flag shows its evidence as hover text and in the detail panel’s Provenance list, and no flag changes anything on a machine.
• VisibleServices The provenance CLI command shows which projects are yours. It lists each project’s git remote, last author, and whether it counts as yours, provenance scan reads the git facts again, and provenance flags lists flagged installs with their evidence. Your projects are named by an optional .scout-data/mine.json holding your GitHub owners and git author emails.
• VisibleServices Scout watches for outages and records each one. Every 2 minutes the hub checks each machine’s ssh port for an SSH greeting, the public hostnames it health-checks, and the services and ports it has seen running. A machine that accepts a connection but sends no greeting counts as hung, and an outage is confirmed after 2 failed checks in a row, so a quick restart raises nothing.
• VisibleServices The Services page has an Outages tab. It lists open and past outages, shows the status of each notice channel, sends a test notice, pauses the watch for 1 or 8 hours, and turns checks on or off by kind, machine, or item. The outages CLI command lists outages, pauses and resumes the watch, and changes the same switches.
• VisibleServices Outage notices reach your desktop and Discord. Each outage and its recovery show a desktop notification on the hub machine, and a Discord post when SCOUT_DISCORD_WEBHOOK holds a Discord webhook address. Outages also appear on the Alerts tab as high-severity alerts.
• VisibleServices A watchdog reports when the hub itself stops. pnpm --filter @scout/hub watchdog (on Windows, tools/run-watchdog.ps1 keeps it running) runs as a second login service on Windows, macOS, or Linux and sends a notice when the hub’s heartbeat goes stale, and a restarted hub records the time it was not running as a monitor gap.
• VisibleServices Outage notices and alerts show the time in the hub machine’s time zone. Outage notices, outage alerts, and unhealthy-endpoint alerts give local time to the second, such as 2026-10-10 15:26:03 MST, and end with the minutes since the last successful check, such as (4 minutes since the last successful check), or say that no successful check is on record. The watchdog notice uses the same time format.
• VisibleServices A pause in the hub no longer shows up as a site going down. If a health probe times out or cannot connect while the hub itself was stuck for 0.75 seconds or more, Scout tries the probe once more before counting it as a failure.
• VisibleServices The hub no longer freezes for seconds after each live read of a machine. Matching listeners to services, checking a machine for stored rows, evaluating alerts, and resolving stacks now work from one shared listing per pass. In normal operation on a catalog of about 6,500 services, the longest pause in the hub is now about 11 milliseconds, down from about 2.5 seconds.
• InternalServices Outage notices read the last passing check from a new last_ok_at column. The column sits in the watch_state table and holds the time each watched item last passed. Scout adds it to an existing catalog the next time the catalog opens, and the other columns stay as they were.
• VisibleServices The outage watch covers only services and ports meant to stay up. Scout watches Windows services that start automatically, launchd jobs with KeepAlive set, their listening ports, and ports served by a container or reached by a published route, so closing an app on purpose no longer raises an alert. Set an item to true under items in .scout-data/watch.json to watch it anyway.
• VisibleServices Public hostnames that have never answered a health probe no longer raise outages. A hostname used only through Tailscale, which returns HTTP 530 from outside, stays quiet until the first time it answers, and then the watch starts. Any outage already open for such a hostname closes without a notice.
• InternalServices The catalog gains outages and watch_state tables. They are created additively the next time the catalog opens, and existing tables are unchanged.
• InternalServices The catalog gains a project_git table. It holds each project’s remote host, owner, and repository and its last commit’s author email and date, refreshed at startup and every 6 hours, and never a credential from a remote URL. It is created additively the next time the catalog opens, and existing tables are unchanged.
• VisibleDocs The setup guide covers outage alerts. It explains what is watched, how to set up Discord notices and the watchdog task, and how to pause the watch for maintenance.
• VisibleCloudflare An optional Cloudflare reader maps your public hostnames to your machines. It reads your zones, DNS, tunnels, Access applications, and Workers routes and changes none of them. Scout never saves the token.
• VisibleSecurity Production mode puts the page behind Cloudflare Access. The hub checks every Access token itself and answers only the hostname you configure.
• VisibleAI Optional AI helpers can summarize release notes and describe projects. They stay off until you set them up with a toolkit script and a local gateway of your own, and they make no more than 30 calls an hour.
• VisibleDocs New guides cover setup, the hub machine, and platform support. The README, setup guide, architecture notes, security policy, and a scout-setup skill explain how to install Scout, why one machine in machines.json is the hub, and what works on Windows, macOS, and Linux today.
• VisibleUI Scout now lives in the Windows tray and the macOS menu bar. The icon’s dot turns amber when something changed and red when something is down, and shows a grey cross when the hub is out of reach. Click it to see what should be running on each machine, plus your stacks.
• VisibleServices The tray panel can start, stop, and restart services. Stop and Restart ask before they run, and protected services never offer them. If an action needs admin rights, approve the UAC prompt on Windows, or run the sudo command the panel shows on a Mac.
• VisibleUI Rows you do not care about can be hidden from the tray panel. Right-click a row to hide it, hide everything of its kind or vendor, or pin it to the top. The new Settings page in the portal lists these rules and can import or export them. Hidden rows are still watched for outages.
• VisibleSecurity The panel signs in with a Cloudflare Access service token. List the token’s Client ID under allowedServiceTokens in access.json, and the hub lets it reach the tray and service action endpoints and nothing else. The panel keeps the secret in Windows Credential Manager or the macOS Keychain.
• InternalServices The hub has /api/tray endpoints and a tray.json rules file. GET /api/tray returns the panel’s rows with an ETag and answers 304 when nothing changed, GET and PUT /api/tray/rules read and replace the rules, and POST /api/tray/hide adds a hide rule. The rules are stored in .scout-data/tray.json.
• VisibleDocs The setup guide explains how to install and connect the tray panel. It walks through the Cloudflare Access service token, the build on Windows and macOS, and starting the panel at login.
• VisibleCLI New status, whois, and map commands show what is running without opening the page. status tells you whether everything is up and lists open outages and anything down or changed on each machine. Give whois a port number or part of a name to see what is using it on every machine, and which program is behind it. map writes a markdown summary of your machines, stacks, and ports that you can save to a notes folder and refresh on a schedule. The commands read the catalog directly, so they work even when the hub is stopped.
• VisibleMCP AI agents can read Scout through its new MCP server. Claude Desktop, Claude Code, and other agents that support the Model Context Protocol can ask Scout for the same status, port lookups, and systems map as the commands, along with services, outages, alerts, and the history of starts, stops, and restarts. The agent starts the server on the hub machine itself, so the server opens no network port.
• VisibleSecurity An agent can start a stopped service, and it cannot stop or restart anything. A start from an agent goes through the same plan, one-time confirmation, and audit log as the page and the tray panel, and Scout refuses it if the service is protected or already running. An agent can ask what a stop or restart would do, but only you can carry one out, from the page, the tray panel, or the CLI. Protected services such as ssh and Scout itself still never offer Stop or Restart.
• InternalMCP The MCP server lives in a new @scout/mcp package with no external dependencies. It answers JSON-RPC 2.0 over standard input and output, and each tool call opens the catalog, answers, and closes it. A start goes through ControlRunner, the same as from the hub’s endpoints. A shared read model in @scout/ops builds the tray panel’s rows from the local catalog and rules files, so the CLI and the MCP server see the same rows as the panel, and @scout/core adds whoIs, statusSummary, and systemsMapMarkdown.
• InternalServices Meter readings are kept in a new meter_samples table. Each row holds the machine id, the time, and the reading as JSON. Samples older than 7 days are deleted when a new one lands, and each machine keeps at most 2000. The table is created additively the next time the catalog opens, and existing tables are unchanged.
• VisibleDocs The setup guide covers the new commands and how to connect an agent. It also shows how to keep the systems map in a notes folder and lists what an agent may change.
• VisibleServices Ports held by a language runtime now name the script it was started with. A port that used to say only “node” now says “node: vite” across the tray panel, the Services page, the listeners command, the systems map, and port-clash messages, and Scout keeps just that path, never the rest of the command line. When Scout is not allowed to look inside a process, such as a service running as administrator, the row still shows the runtime name.

Changed

• VisibleServices Health checks run every 2 minutes instead of every 5. --health-interval still sets the period in seconds.

Fixed

• VisibleUI Saving the portal as an app now picks up the Scout icon. The page lists its 192 and 512 pixel icons as page icons, gives the manifest an id, and registers a small service worker that caches nothing, so a browser treats it as installable. The hub also lets a browser keep the icons and the manifest for an hour instead of marking them uncacheable.
• VisibleServices Reads and actions over ssh stop failing at random on a Windows hub machine. The ssh program that comes with Windows exits with a crash code on about half of its runs, even after it has printed everything, so a finished read looked like a failure. Scout now runs the ssh that ships with Git for Windows when it is installed, which ran clean in every test, and the SCOUT_SSH environment variable names a different ssh program.
• VisibleServices Stop and Restart no longer give up when one read of a machine is slow. If a probe is slow or dropped while a stop or restart plan reads the machine, Scout now reads it once more before refusing with “The machine state could not be read.” A machine that cannot be reached at all still gets that refusal. The error had blocked Stop and Restart on a Mac reached over ssh.
• VisibleServices Listeners behind a Windows service wrapper show their real command. When a wrapper such as shawl runs a program as a Windows service with administrator rights, Scout cannot read that process’s command line, so its listener used to show as plain node. ARK Overseer on port 3310 was one of these. Scout now takes the real command from the wrapper’s service entry, and the row shows the program path and the script it runs.
• VisibleServices Launch recipes start the real program instead of opening a script in an editor. When pnpm or a similar command resolved to a .ps1 script, starting a recipe opened that script in the editor set for .ps1 files, and Scout reported the recipe as running even though nothing had started. The launcher now starts the matching .exe, .cmd, .bat, or .com file on PATH, and if no such file exists the action fails without launching anything.
• VisibleServices A recipe without a port is checked twice after launch. The checks run about 3 and 8 seconds after it starts, and the result says whether the process was still running at 8 seconds or exited sooner. A stack that includes such a recipe now waits 8 seconds for it instead of 3.