@oddessentials/agent-guild 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Odd Essentials
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# Agent Guild
+
+Agent Guild runs AI coding assistants side by side from one local web page.
+Pick a provider, get a real interactive terminal running that provider's
+coding tool, and see at a glance which sessions and agents are working.
+
+![Agent Guild session cards](docs/screenshot.png)
+
+* **Start sessions from provider cards.** Anthropic (Claude Code), OpenAI
+  (Codex CLI), Google (Gemini CLI), xAI (Grok Build), and a plain shell.
+  **New** starts a fresh session; **Existing** resumes one of
+  the tool's own earlier sessions from its id. Providers whose tool is not
+  installed are shown greyed out with an **Install** button that runs
+  `npm install -g` in a session you can watch, or with install instructions
+  when the tool is not an npm package. Installed tools show their version
+  and an **Update** button; updating while that tool's sessions are running
+  asks first, because it can break them.
+* **See what is left of your limits.** Claude Code, Codex CLI and Gemini
+  CLI cards show a meter per rate-limit window (5-hour, 7-day, or per
+  model, including Claude's weekly Fable window and the model and feature
+  limits Codex meters separately) with the time until it resets, read from
+  the tool's own sign-in.
+  Claude's extra-usage spend and Codex's prepaid credit balance appear
+  when the account has them. Other providers can supply a command that
+  prints usage.
+* **Work in real terminals.** Each session is a card. Open it for a full
+  interactive terminal: type instructions, answer prompts, watch output. Run
+  as many sessions at once as you like.
+* **See agents and models at work.** When a coding tool reports helper
+  agents, they appear as small icons on that session's card. The card also
+  names the main model in use, reported by the tool or, failing that,
+  spotted on its screen.
+* **Close the page any time.** A separate local session manager owns the
+  terminals. Reopen the page and it reconnects to the same sessions with
+  their screens intact, as long as the manager is still running. Sessions do
+  not survive a computer restart. **Stop manager** in the top bar stops the
+  manager and ends every session; it asks first while any session is still
+  running.
+
+## Requirements
+
+* Windows 10 1809 or later, or macOS 11 or later. Linux works for development.
+* Node.js 22 or newer.
+* Each coding tool you want to use, signed in on its own. Agent Guild can
+  install the npm-packaged tools for you; it does not authenticate them.
+
+node-pty ships prebuilt binaries for Windows, macOS and Linux on x64 and
+arm64, so no compiler is needed. WSL is not required.
+
+## Install and run
+
+```sh
+npm install -g @oddessentials/agent-guild
+agent-guild
+```
+
+`agent-guild open` starts the session manager in the background if needed and
+opens the page. The page URL carries an access token in its `#` fragment. The
+page stores it and then removes it from the address bar.
+
+| Command | What it does |
+| --- | --- |
+| `agent-guild` or `agent-guild open` | Start the manager if needed and open the page. `--no-browser` prints the URL instead. |
+| `agent-guild status` | Show whether the manager is running and list its sessions. |
+| `agent-guild stop` | Stop the manager. This ends every session, without asking. The page's **Stop manager** button does the same and asks first while sessions are running. |
+| `agent-guild start` | Run the manager in the foreground, for debugging. |
+| `agent-guild url` | Print the page URL with its token. |
+
+## Configure providers
+
+Create `providers.json` in the data folder to change or add providers:
+
+| Platform | Data folder |
+| --- | --- |
+| Windows | `%APPDATA%\AgentGuild` |
+| macOS | `~/Library/Application Support/AgentGuild` |
+
+Entries are merged with the built-in ones by `id`. A new `id` adds a
+provider, and `"enabled": false` hides one. Any field can be overridden for
+one platform under a `win32` or `darwin` key. See
+[examples/providers.json](examples/providers.json).
+
+| Field | Meaning |
+| --- | --- |
+| `id` | Lowercase identifier. |
+| `vendor`, `tool` | Names shown on the icon. |
+| `command`, `args` | What to run. `command` is looked up on PATH. `@shell` means the user's default shell. |
+| `package` | The tool's npm package, e.g. `@openai/codex`. Enables the **Install** button and the version check. |
+| `channels` | How an installed copy is recognised, so **Update** runs that installation's own updater. A copy installed by npm needs no entry. `brew.names` lists the tool's own Homebrew formula or cask names, e.g. `{ "brew": { "names": ["gemini-cli"] } }`, and `winget.id` is its WinGet package id. A provider you add must set these for its Homebrew or WinGet copy to get an **Update** button or a removal command; without them that copy shows as an unknown install with guidance only. `native.paths` are the launcher and folders the vendor's own installer uses, and `native.update` the arguments that make the tool update itself, e.g. `["update"]`. |
+| `versionArgs` | Arguments that make the command print its version, used instead of `args`, e.g. `["--version"]`. |
+| `usage` | Where the usage meters come from: `"claude"`, `"codex"`, `"gemini"`, `{ "command", "args" }` for a program that prints `{ "windows": [{ "label", "usedPercent", "resetsAt" }] }`, or `null` for none. |
+| `modelPattern` | Regular expression that finds the model name on the tool's screen when the tool does not report it. |
+| `resumeArgs` | Arguments that resume the tool's own session, with `{id}` standing for the id, e.g. `["--resume", "{id}"]`. Without it the card has no **Existing** button. |
+| `env` | Extra environment variables for the tool. |
+| `color`, `monogram`, `icon` | Icon appearance. `icon` is a URL path; you can also drop `<id>.svg` into `web/icons/`. |
+| `install`, `docs` | Help shown when the tool is not installed. |
+| `usageUrl`, `billingUrl` | `https://` links to the vendor's usage and billing pages, shown on the card. The defaults point at the subscription pages; set your API console instead, or `null` to hide a link. Google's usage link opens AI Studio, which counts API-key usage only, not the Gemini CLI sign-in quota the card's meters show. |
+
+The page's "Working folder" field sets where new sessions start. It defaults
+to your home folder.
+
+Version checks ask the registry from npm's global configuration (the one
+`npm install -g` uses) about once an hour, and installs use the same
+registry. Set `AGENT_GUILD_NPM_REGISTRY` to override it for both, or
+`AGENT_GUILD_NO_UPDATE_CHECK=1` to skip the checks.
+
+## Show agents and models
+
+Agents are reported by the coding tool, not guessed from its output. Add
+the hooks from the matching file in [examples/](examples/) to Claude Code,
+Codex CLI, Gemini CLI or Grok Build: each sub-agent appears on the card
+while it runs, and the card shows the model in use. The hooks call
+`agent-guild-report`, which the manager puts on the PATH of every session it
+starts, so no global install is needed. Codex CLI runs no hook until you
+trust it (choose "Trust all and continue" when it starts, or run `/hooks`),
+and Claude Code runs none until you accept its workspace-trust prompt. Any
+tool or script can also report agents and the model with the
+`agent-guild-report` command or an escape sequence. See
+[docs/agent-reporting.md](docs/agent-reporting.md).
+
+## Security
+
+* The manager listens on `127.0.0.1` only.
+* Every API call needs a random per-user token, stored in the data folder
+  with owner-only permissions.
+* Requests with a foreign `Host` or `Origin` header are refused. This stops
+  other websites from reaching the terminals through your browser.
+* Tools inside a session get a separate token that can only report agents
+  for that session.
+* Usage meters are fetched by the manager with the coding tool's own
+  sign-in (Claude Code's credentials, Codex CLI's `auth.json`, Gemini CLI's
+  sign-in). The page only ever receives percentages. On macOS the first
+  lookup may ask for keychain access to the "Claude Code-credentials" and
+  "gemini-cli-oauth" items; choose Always Allow.
+
+Anyone who can run programs as your user can already read the token, as with
+any local developer tool.
+
+## Other front ends
+
+The page is only one client. The manager's API is documented in
+[docs/api.md](docs/api.md) so that another interface, such as a planned
+Unreal Engine version where provider characters and their workers stand in
+for the icons, can drive the same sessions. See
+[docs/architecture.md](docs/architecture.md).
+
+## Development
+
+```sh
+npm install
+npm test
+```
+
+The tests start real managers and real pseudo-terminals, using a small fake
+coding tool in `tests/fixtures`. CI runs them on Windows, macOS and Linux.
+
+## Current limits
+
+* Sessions end when the manager stops or the computer restarts.
+* Gemini CLI usage meters need its sign-in in the OS keychain (macOS, or
+  Linux with `secret-tool`) or in the older `oauth_creds.json`; Gemini CLI's
+  encrypted-file storage cannot be read.

package/bin/agent-guild-report.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+// Report an agent, or the model in use, inside an Agent Guild session.
+//
+// The session manager injects AGENT_GUILD_URL, AGENT_GUILD_SESSION_ID and
+// AGENT_GUILD_REPORT_TOKEN into every terminal it starts. Outside such a
+// terminal this command does nothing and exits 0, so hooks that call it are
+// harmless when the tool runs elsewhere.
+//
+//   agent-guild-report <agent-id> [--name N] [--status working|waiting|idle|done]
+//                      [--detail TEXT] [--kind KIND] [--remove]
+//   agent-guild-report --model NAME [--display-name TEXT]
+//   agent-guild-report --hook                (reads a hook event as JSON on stdin:
+//                                             Claude Code, Codex CLI, Gemini CLI, Grok Build)
+//   agent-guild-report --claude-statusline [--passthrough]
+//                      (reads Claude Code status line JSON on stdin; prints a
+//                       status line, or the JSON itself with --passthrough)
+
+import { hookToReports, claudeStatuslineToReport, formatStatusLine } from '../src/report/hooks.mjs';
+
+const env = process.env;
+const inSession = env.AGENT_GUILD_URL && env.AGENT_GUILD_SESSION_ID && env.AGENT_GUILD_REPORT_TOKEN;
+// Gemini CLI's optional environment redaction removes every variable whose
+// name contains TOKEN before it runs a hook. Say so instead of staying silent.
+if (!inSession && env.AGENT_GUILD_SESSION_ID && !env.AGENT_GUILD_REPORT_TOKEN) {
+  console.error('agent-guild-report: AGENT_GUILD_REPORT_TOKEN is missing from the environment; the tool may be redacting variables named *TOKEN*');
+}
+
+const USAGE = `Usage: agent-guild-report <agent-id> [--name N] [--status working|waiting|idle|done] [--detail TEXT] [--kind KIND] [--remove]
+       agent-guild-report --model NAME [--display-name TEXT]
+       agent-guild-report --hook                           (reads a coding tool's hook event JSON from stdin)
+       agent-guild-report --claude-statusline [--passthrough]  (reads Claude Code status line JSON from stdin)`;
+
+function parseArgs(argv) {
+  const out = { positional: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--remove') out.remove = true;
+    else if (a === '--hook' || a === '--claude-hook') out.hook = true;
+    else if (a === '--claude-statusline') out.claudeStatusline = true;
+    else if (a === '--passthrough') out.passthrough = true;
+    else if (a === '-h' || a === '--help') out.help = true;
+    else if (a.startsWith('--') && a.includes('=')) {
+      const eq = a.indexOf('=');
+      out[a.slice(2, eq)] = a.slice(eq + 1);
+    } else if (a.startsWith('--')) out[a.slice(2)] = argv[++i];
+    else out.positional.push(a);
+  }
+  return out;
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => { data += c; });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(data));
+  });
+}
+
+async function send(report) {
+  const kind = report.agentId !== undefined || report.finishForeground === true ? 'agents' : 'model';
+  const url = `${env.AGENT_GUILD_URL}/api/v1/sessions/${env.AGENT_GUILD_SESSION_ID}/${kind}`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Agent-Guild-Report-Token': env.AGENT_GUILD_REPORT_TOKEN,
+    },
+    body: JSON.stringify(report),
+    signal: AbortSignal.timeout(3000),
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`HTTP ${res.status}: ${body}`);
+  }
+}
+
+/** A hook must never break the coding tool, so report failures quietly. */
+const sendQuietly = (report) => send(report).catch((err) => console.error(`agent-guild-report: ${err.message}`));
+
+function parseJson(raw) {
+  try { return JSON.parse(raw); } catch { return null; }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(USAGE);
+    return;
+  }
+  if (args.hook) {
+    const input = parseJson(await readStdin());
+    if (!inSession || !input) return;
+    for (const report of hookToReports(input)) await sendQuietly(report);
+    return;
+  }
+  if (args.claudeStatusline) {
+    const raw = await readStdin();
+    const input = parseJson(raw);
+    process.stdout.write(args.passthrough ? raw : `${formatStatusLine(input)}\n`);
+    if (!inSession || !input) return;
+    const report = claudeStatuslineToReport(input);
+    if (report) await sendQuietly(report);
+    return;
+  }
+  if (args.model !== undefined && args.positional.length === 0) {
+    if (!args.model) {
+      console.error('agent-guild-report: --model needs a name');
+      process.exitCode = 2;
+      return;
+    }
+    if (!inSession) return;
+    await send({ model: args.model, displayName: args['display-name'] });
+    return;
+  }
+  const agentId = args.positional[0];
+  if (!agentId) {
+    console.error('agent-guild-report: an agent id is required (see --help)');
+    process.exitCode = 2;
+    return;
+  }
+  if (!inSession) return;
+  const report = { agentId };
+  for (const key of ['name', 'status', 'detail', 'kind']) if (args[key] !== undefined) report[key] = args[key];
+  if (args.remove) report.remove = true;
+  await send(report);
+}
+
+main().catch((err) => {
+  console.error(`agent-guild-report: ${err.message}`);
+  process.exitCode = 1;
+});

package/bin/agent-guild.mjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+// Agent Guild launcher.
+//
+//   agent-guild [open]     start the session manager if needed, open the page
+//   agent-guild start      run the session manager in the foreground
+//   agent-guild stop       stop the manager (ends all sessions)
+//   agent-guild status     show whether the manager is running
+//   agent-guild url        print the page URL (includes the access token)
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import {
+  DEFAULT_HOST,
+  VERSION,
+  ensureDataDir,
+  loadOrCreateToken,
+  paths,
+  readRuntimeFile,
+  resolvePort,
+} from '../src/manager/config.mjs';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const managerEntry = path.resolve(here, '../src/manager/main.mjs');
+
+function usage() {
+  console.log(`Usage: agent-guild [command] [--no-browser]
+
+Commands:
+  open      Start the session manager if needed and open the web page (default)
+  start     Run the session manager in the foreground
+  stop      Stop the session manager and every session it owns
+  status    Show whether the session manager is running
+  url       Print the web page URL, including the access token
+
+Environment:
+  AGENT_GUILD_PORT             Port for the local API (default 47821)
+  AGENT_GUILD_HOME             Data directory (default: per-user app data folder)
+  AGENT_GUILD_NPM_REGISTRY     npm registry for version checks and installs
+  AGENT_GUILD_NO_UPDATE_CHECK  Set to 1 to skip version checks`);
+}
+
+function baseUrl() {
+  const runtime = readRuntimeFile();
+  if (runtime?.url) return runtime.url;
+  return `http://${DEFAULT_HOST}:${resolvePort()}`;
+}
+
+async function health(url, timeoutMs = 1000) {
+  try {
+    const res = await fetch(`${url}/api/v1/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return body?.name === 'agent-guild' ? body : null;
+  } catch {
+    return null;
+  }
+}
+
+function pageUrl(url, token) {
+  return `${url}/#token=${token}`;
+}
+
+function versionNotice(running) {
+  if (!running || running === VERSION) return null;
+  return `The running manager is version ${running}; the installed Agent Guild is ${VERSION}. ` +
+    `Run "agent-guild stop" to end its sessions, then start again to use ${VERSION}.`;
+}
+
+function openBrowser(url) {
+  const opts = { detached: true, stdio: 'ignore' };
+  let child;
+  if (process.platform === 'darwin') child = spawn('open', [url], opts);
+  else if (process.platform === 'win32') {
+    // rundll32 avoids cmd.exe's special handling of characters like "&" in URLs.
+    child = spawn('rundll32', ['url.dll,FileProtocolHandler', url], { ...opts, windowsHide: true });
+  } else child = spawn('xdg-open', [url], opts);
+  child.on('error', () => console.log(`Could not open a browser automatically. Open this URL:\n  ${url}`));
+  child.unref();
+}
+
+function tailLog(lines = 15) {
+  try {
+    return fs.readFileSync(paths.log, 'utf8').trimEnd().split('\n').slice(-lines).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+const MAX_LOG_BYTES = 5 * 1024 * 1024;
+
+/** Keep one previous log so the file cannot grow without bound. */
+function rotateLog() {
+  try {
+    if (fs.statSync(paths.log).size > MAX_LOG_BYTES) fs.renameSync(paths.log, `${paths.log}.1`);
+  } catch { /* no log yet */ }
+}
+
+async function ensureManager() {
+  const running = await health(baseUrl());
+  if (running) return { url: baseUrl(), started: false, version: running.version };
+
+  ensureDataDir();
+  rotateLog();
+  const log = fs.openSync(paths.log, 'a');
+  fs.writeSync(log, `\n--- starting manager ${new Date().toISOString()} ---\n`);
+  const child = spawn(process.execPath, [managerEntry], {
+    detached: true,
+    stdio: ['ignore', log, log],
+    windowsHide: true,
+    env: process.env,
+  });
+  child.unref();
+  fs.closeSync(log);
+
+  let exited = false;
+  child.once('exit', () => { exited = true; });
+  const deadline = Date.now() + 20000;
+  const expectedUrl = `http://${DEFAULT_HOST}:${resolvePort()}`;
+  while (Date.now() < deadline && !exited) {
+    await new Promise((r) => setTimeout(r, 250));
+    const url = readRuntimeFile()?.pid === child.pid ? readRuntimeFile().url : expectedUrl;
+    const up = await health(url, 500);
+    if (up) return { url, started: true, version: up.version };
+  }
+  // Two launchers started together both try to start a manager; the one
+  // that lost the race should use the winner rather than report a failure.
+  const winner = await health(expectedUrl, 1000);
+  if (winner) return { url: expectedUrl, started: false, version: winner.version };
+  const details = tailLog();
+  throw new Error(`the session manager did not start.${details ? `\n\nRecent log (${paths.log}):\n${details}` : ''}`);
+}
+
+async function cmdOpen({ browser }) {
+  const { url, started, version } = await ensureManager();
+  const token = loadOrCreateToken();
+  const target = pageUrl(url, token);
+  console.log(started ? `Session manager started at ${url}` : `Session manager already running at ${url}`);
+  const notice = versionNotice(version);
+  if (notice) console.log(notice);
+  if (browser) {
+    openBrowser(target);
+    console.log('Opening Agent Guild in your browser. You can close the page at any time; sessions keep running.');
+  } else {
+    console.log(`Open: ${target}`);
+  }
+}
+
+async function cmdStop() {
+  const url = baseUrl();
+  if (!(await health(url))) {
+    console.log('Session manager is not running.');
+    return;
+  }
+  // `stop` is documented as ending every session, so it does not ask; the
+  // web page's Stop manager button is the one that confirms first.
+  const res = await fetch(`${url}/api/v1/shutdown`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${loadOrCreateToken()}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ force: true }),
+  });
+  if (!res.ok) throw new Error(`stop failed: HTTP ${res.status}`);
+  const { running = 0 } = await res.json().catch(() => ({}));
+  if (running > 0) console.log(`Ending ${running} running session(s).`);
+  for (let i = 0; i < 40; i++) {
+    await new Promise((r) => setTimeout(r, 150));
+    if (!(await health(url, 300))) {
+      console.log('Session manager stopped.');
+      return;
+    }
+  }
+  console.log('Stop requested; the manager is still shutting down.');
+}
+
+async function cmdStatus() {
+  const url = baseUrl();
+  const h = await health(url);
+  if (!h) {
+    console.log('Session manager is not running.');
+    process.exitCode = 3;
+    return;
+  }
+  const res = await fetch(`${url}/api/v1/sessions`, { headers: { Authorization: `Bearer ${loadOrCreateToken()}` } });
+  const { sessions = [] } = res.ok ? await res.json() : {};
+  const running = sessions.filter((s) => s.status === 'running').length;
+  console.log(`Session manager ${h.version} running at ${url} (pid ${h.pid}).`);
+  const notice = versionNotice(h.version);
+  if (notice) console.log(notice);
+  console.log(`${sessions.length} session(s), ${running} running.`);
+  for (const s of sessions) {
+    const model = s.model ? ` [${s.model.displayName || s.model.name}]` : '';
+    const agents = s.agents.length ? `, ${s.agents.length} agent(s)` : '';
+    console.log(`  ${s.id}  ${s.provider.vendor.padEnd(10)} ${s.status.padEnd(8)} ${s.name}${model}${agents}`);
+  }
+}
+
+const MIN_NODE_MAJOR = 22;
+
+async function main() {
+  const major = Number(process.versions.node.split('.')[0]);
+  if (major < MIN_NODE_MAJOR) {
+    throw new Error(`Node.js ${MIN_NODE_MAJOR} or newer is required; this is ${process.versions.node}. Install a current LTS from https://nodejs.org.`);
+  }
+  const args = process.argv.slice(2);
+  const flags = new Set(args.filter((a) => a.startsWith('-')));
+  const command = args.find((a) => !a.startsWith('-')) || 'open';
+  if (flags.has('-h') || flags.has('--help') || command === 'help') return usage();
+
+  switch (command) {
+    case 'open': return cmdOpen({ browser: !flags.has('--no-browser') });
+    case 'start': {
+      await import('../src/manager/main.mjs').then(async (m) => {
+        process.on('uncaughtException', (err) => console.error('[manager] unexpected error:', err));
+        process.on('unhandledRejection', (err) => console.error('[manager] unhandled rejection:', err));
+        const { shutdown } = await m.startManager();
+        console.log(`Open: ${pageUrl(readRuntimeFile()?.url ?? baseUrl(), loadOrCreateToken())}`);
+        for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+          process.on(sig, () => shutdown(sig).then(() => process.exit(0)));
+        }
+      });
+      return undefined;
+    }
+    case 'stop': return cmdStop();
+    case 'status': return cmdStatus();
+    case 'url': {
+      console.log(pageUrl(baseUrl(), loadOrCreateToken()));
+      return undefined;
+    }
+    default:
+      usage();
+      process.exitCode = 2;
+      return undefined;
+  }
+}
+
+main().catch((err) => {
+  console.error(`agent-guild: ${err.message}`);
+  process.exit(1);
+});