relay-codex 0.0.0-stage → 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 blackspider-ops
+
+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

@@ -1,3 +1,100 @@
-# Temporary Holding Version
+<p align="center"><img src="https://raw.githubusercontent.com/blackspider-ops/relay/main/assets/relay.svg" alt="Relay — keep Codex moving" width="840"></p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Relay keeps your Codex sessions moving between your own accounts. When an account
+runs out, it finds another available account. When all accounts are waiting for a
+reset, it waits too, then continues the saved task.
+
+**macOS · Native Codex terminal · One account or many**
+
+## Get started
+
+You'll need [Codex](https://learn.chatgpt.com/docs/cli), Node.js 20 or newer, and
+Python 3.11 or newer. If you use Homebrew, `brew install node python@3.13` installs
+Node and Python.
+
+```sh
+npm install -g github:blackspider-ops/relay#v0.4.1
+relay setup --count 2
+relay run
+```
+
+Choose however many accounts you have. Each person signs into their own accounts;
+this project does not include anyone's saved logins. Existing logins from the
+earlier `codex-accounts` tool are picked up automatically.
+
+The first run downloads Relay's Python libraries. Later runs use the saved copy.
+Your usual `codex` command keeps working.
+
+Prefer trying it without a global install?
+
+```sh
+npx --yes github:blackspider-ops/relay#v0.4.1 setup --count 2
+npx --yes github:blackspider-ops/relay#v0.4.1 run
+```
+
+## Use it like Codex
+
+```sh
+relay run -- resume --yolo
+relay status --watch
+```
+
+`--yolo` keeps its usual full-access meaning. Without it, Relay keeps the task's
+permissions. Different terminals can work on different conversations at once.
+
+If a conversation is already open in another app, close it there before resuming
+it here, or use Codex's `fork` command for a separate copy. To move a Relay task
+between terminals:
+
+```sh
+relay attach --takeover SESSION_ID
+```
+
+## What happens when something stops?
+
+- **Account limit:** use an available account, or wait for the earliest usable reset.
+- **One account:** wait for its reset and continue the same conversation.
+- **Connection or sign-in failure:** retry at 5, 10, and 15 minutes, then try another account.
+- **“Selected model is at capacity”:** wait five minutes and try the same model again.
+  Relay keeps waiting rather than cycling logins. A different model is used only
+  if you explicitly configure a fallback.
+- **An unclear interruption during a command:** pause for review before continuing.
+  Relay cannot guarantee that an external action happened exactly once.
+
+## Leave work running
+
+```sh
+relay start --name website --cwd ~/projects/website --prompt "Finish the remaining checks"
+relay attach SESSION_ID
+relay stop SESSION_ID
+```
+
+Background tasks keep running after their terminal closes. They do not start
+automatically after a Mac reboot. Use `relay status --all` to find saved sessions
+and `relay restart SESSION_ID` to recover a stopped one.
+
+## A few useful commands
+
+```sh
+relay add personal
+relay account disable personal
+relay pause SESSION_ID
+relay unpause SESSION_ID
+relay retry SESSION_ID
+relay doctor --self-test
+relay menubar
+```
+
+Accounts stay in your Mac's Keychain. Relay keeps its settings and task records
+in your private Application Support folder. Never share that folder.
+
+## Updates and limits
+
+Relay checks the installed Codex version and keeps a working copy for running
+sessions. Future Codex changes may still need a Relay update.
+
+This is an independent tool, not an OpenAI product. Short local tests cover
+parallel tasks and recovery; they are not an overnight reliability guarantee.
+
+[Commands](docs/commands.md) · [Troubleshooting](docs/troubleshooting.md) ·
+[Publishing to npm or Homebrew](docs/publishing.md) · [Contributing](CONTRIBUTING.md)

package/assets/relay.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1280" height="360" viewBox="0 0 1280 360" role="img" aria-labelledby="title desc">
+  <title id="title">Relay</title>
+  <desc id="desc">Keep Codex moving. Four paths meet in one forward arrow.</desc>
+  <rect width="1280" height="360" rx="24" fill="#111916"/>
+  <g fill="none" stroke="#a8d9bd" stroke-width="10" stroke-linecap="round">
+    <path d="M96 108h62c48 0 44 72 94 72h44" opacity=".5"/>
+    <path d="M96 156h82c34 0 30 24 72 24h46" opacity=".7"/>
+    <path d="M96 204h82c34 0 30-24 72-24h46"/>
+    <path d="M96 252h62c48 0 44-72 94-72h44" opacity=".5"/>
+    <path d="m278 158 24 22-24 22" stroke="#f7be74"/>
+  </g>
+  <text x="366" y="185" fill="#f5f3ec" font-family="Helvetica Neue,Arial,sans-serif" font-size="98" font-weight="650" letter-spacing="-5">Relay</text>
+  <text x="371" y="239" fill="#acb9b0" font-family="Helvetica Neue,Arial,sans-serif" font-size="27" letter-spacing=".2">Keep Codex moving.</text>
+  <text x="1140" y="73" text-anchor="end" fill="#a8d9bd" font-family="Menlo,monospace" font-size="15">FOR YOUR TERMINAL</text>
+</svg>

package/bin/relay.cjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync, spawn } = require('node:child_process');
+const { setTimeout: delay } = require('node:timers/promises');
+
+const packageRoot = path.resolve(__dirname, '..');
+const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+
+function stateDirectory(env = process.env, home = os.homedir()) {
+  if (env.RELAY_STATE || env.CODEX_ACCOUNTS_STATE) {
+    return path.resolve(env.RELAY_STATE || env.CODEX_ACCOUNTS_STATE);
+  }
+  const support = path.join(home, 'Library', 'Application Support');
+  const legacy = path.join(support, 'Codex Accounts');
+  return fs.existsSync(path.join(legacy, 'accounts')) ? legacy : path.join(support, 'Relay');
+}
+
+function pythonCommand() {
+  const choices = [process.env.RELAY_PYTHON, 'python3', 'python3.14', 'python3.13', 'python3.12', 'python3.11'].filter(Boolean);
+  for (const command of choices) {
+    const result = spawnSync(command, ['-c', 'import sys; print(sys.executable); raise SystemExit(sys.version_info < (3, 11))'], { encoding: 'utf8' });
+    if (result.status === 0) return result.stdout.trim();
+  }
+  throw new Error('Relay needs Python 3.11 or newer. Install it with: brew install python@3.13');
+}
+
+function privateDirectory(directory) {
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const info = fs.lstatSync(directory);
+  if (info.isSymbolicLink() || (process.getuid && info.uid !== process.getuid())) {
+    throw new Error('Relay needs a private folder owned by your user.');
+  }
+  fs.chmodSync(directory, 0o700);
+}
+
+function fingerprint() {
+  const source = path.join(packageRoot, 'python');
+  const names = fs.readdirSync(source).filter(name => /\.(py|swift|lock|txt)$/.test(name)).sort();
+  for (const name of fs.readdirSync(path.join(packageRoot, 'tests')).filter(name => name.endsWith('.py')).sort()) names.push(`tests/${name}`);
+  const hash = crypto.createHash('sha256');
+  hash.update(pkg.version);
+  for (const name of names) hash.update(name).update(fs.readFileSync(name.startsWith('tests/') ? path.join(packageRoot, name) : path.join(source, name)));
+  return { id: `${pkg.version}-${hash.digest('hex').slice(0, 16)}`, names, source };
+}
+
+function processBirth(pid) {
+  const result = spawnSync('/bin/ps', ['-p', String(pid), '-o', 'lstart='], { encoding: 'utf8' });
+  return result.status === 0 ? result.stdout.trim() : '';
+}
+
+function ownerAlive(owner) {
+  try {
+    process.kill(owner.pid, 0);
+    return Boolean(owner.birth) && processBirth(owner.pid) === owner.birth;
+  } catch { return false; }
+}
+
+async function withSetupLock(state, operation) {
+  const lock = path.join(state, 'relay-setup.lock');
+  const deadline = Date.now() + 10 * 60 * 1000;
+  while (true) {
+    try { fs.mkdirSync(lock, { mode: 0o700 }); break; }
+    catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      let stale = false;
+      try {
+        const owner = JSON.parse(fs.readFileSync(path.join(lock, 'owner.json'), 'utf8'));
+        stale = !ownerAlive(owner);
+      } catch {
+        // Another process may be between mkdir and writing its owner record.
+        try { stale = Date.now() - fs.statSync(lock).mtimeMs > 30_000; }
+        catch (error) { if (error.code === 'ENOENT') continue; throw error; }
+      }
+      if (stale) {
+        const abandoned = `${lock}.stale-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+        try { fs.renameSync(lock, abandoned); fs.rmSync(abandoned, { recursive: true, force: true }); }
+        catch (error) { if (!['ENOENT', 'EEXIST'].includes(error.code)) throw error; }
+        continue;
+      }
+      if (Date.now() > deadline) throw new Error('Another Relay setup is still running. Let it finish, then try again.');
+      await delay(200);
+    }
+  }
+  fs.writeFileSync(path.join(lock, 'owner.json'), JSON.stringify({ pid: process.pid, birth: processBirth(process.pid) }), { mode: 0o600 });
+  try { return await operation(); }
+  finally { fs.rmSync(lock, { recursive: true, force: true }); }
+}
+
+function run(command, args) {
+  const result = spawnSync(command, args, { stdio: 'inherit' });
+  if (result.error || result.status !== 0) throw new Error('Setup did not finish. Run Relay again to retry.');
+}
+
+async function prepare(state) {
+  const bundle = fingerprint();
+  const destination = path.join(state, 'relay-runtimes', bundle.id);
+  const interpreter = path.join(destination, '.venv', 'bin', 'python');
+  const marker = path.join(destination, 'ready.json');
+  const ready = () => fs.existsSync(marker) && fs.existsSync(interpreter) && spawnSync(interpreter, ['-c', 'import websockets, jsonschema'], { stdio: 'ignore' }).status === 0;
+  if (ready()) return { interpreter, router: path.join(destination, 'router.py') };
+  const python = pythonCommand();
+  return withSetupLock(state, async () => {
+    if (ready()) return { interpreter, router: path.join(destination, 'router.py') };
+    privateDirectory(destination);
+    for (const name of bundle.names) {
+      const source = name.startsWith('tests/') ? path.join(packageRoot, name) : path.join(bundle.source, name);
+      fs.mkdirSync(path.dirname(path.join(destination, name)), { recursive: true, mode: 0o700 });
+      fs.copyFileSync(source, path.join(destination, name));
+    }
+    console.error('Preparing Relay for this Mac. This only happens on first use or after an update.');
+    // Always retry dependency installation if a previous setup was interrupted.
+    run(python, ['-m', 'venv', path.join(destination, '.venv')]);
+    run(interpreter, ['-m', 'pip', 'install', '--disable-pip-version-check', '-r', path.join(destination, 'requirements.lock')]);
+    fs.writeFileSync(marker, JSON.stringify({ version: pkg.version }), { mode: 0o600 });
+    return { interpreter, router: path.join(destination, 'router.py') };
+  });
+}
+
+async function main() {
+  if (process.platform !== 'darwin') throw new Error('Relay currently supports macOS.');
+  if (process.argv.length === 3 && ['--version', '-V'].includes(process.argv[2])) {
+    console.log(`Relay ${pkg.version}`); return;
+  }
+  const state = stateDirectory(); privateDirectory(state);
+  const runtime = await prepare(state);
+  const child = spawn(runtime.interpreter, [runtime.router, ...process.argv.slice(2)], {
+    stdio: 'inherit', env: { ...process.env, RELAY_STATE: state, CODEX_ACCOUNTS_STATE: state }
+  });
+  // Terminal Ctrl-C already reaches both foreground processes.
+  const interrupt = () => {};
+  const terminate = () => child.kill('SIGTERM');
+  process.on('SIGINT', interrupt); process.on('SIGTERM', terminate);
+  process.on('SIGHUP', terminate);
+  child.on('error', () => { console.error('Relay could not start. Run it again to retry.'); process.exitCode = 1; });
+  await new Promise(resolve => child.on('close', (code, signal) => {
+    process.exitCode = code ?? (signal === 'SIGINT' ? 130 : 1); resolve();
+  }));
+  process.off('SIGINT', interrupt); process.off('SIGTERM', terminate);
+  process.off('SIGHUP', terminate);
+}
+
+module.exports = { stateDirectory, fingerprint, ownerAlive, withSetupLock, prepare };
+if (require.main === module) main().catch(error => { console.error(`relay: ${error.message}`); process.exitCode = 1; });

package/docs/commands.md

@@ -0,0 +1,92 @@
+# Commands
+
+## Accounts
+
+```sh
+relay setup --count 1
+relay setup --count 6
+relay add personal
+relay list
+relay refresh
+relay account rename account1 personal
+relay account enable personal
+relay account disable personal
+relay account priority personal 10
+relay account cap personal 2
+relay account models personal YOUR_MODEL
+relay account reauth personal
+relay account remove personal
+```
+
+Renaming changes the label, so saved logins stay usable. A cap of zero means no
+session cap. Removing an account keeps its login unless `--revoke` is requested.
+Switch active sessions away from an account before signing it out or replacing it.
+
+## Sessions
+
+```sh
+relay run --name website -- --model YOUR_MODEL
+relay run -- resume --yolo
+relay start --name website --cwd ~/projects/website --prompt "Run the checks"
+relay status --watch
+relay status --all
+relay status --json
+relay attach SESSION_ID
+relay attach --takeover SESSION_ID
+relay pause SESSION_ID
+relay unpause SESSION_ID
+relay retry SESSION_ID
+relay switch SESSION_ID --account personal
+relay stop SESSION_ID
+relay restart SESSION_ID
+```
+
+Session IDs can be shortened as long as the prefix is unique. `pause` pauses
+automatic recovery; it lets a command already running finish. `retry` explicitly
+overrides the retry timer. Switching waits for an idle task; it does not interrupt
+a command or invent an approval.
+
+## Preferences
+
+```sh
+relay config
+relay config notifications true
+relay config background_on_disconnect true
+relay config retry_interval 300
+relay config retry_attempts 3
+relay config routing quota
+relay config preferred_accounts '["account1","account3"]'
+relay config fallback_models '["YOUR_CHOSEN_MODEL"]'
+relay config retry_interval 60 --profile quick
+relay run --profile quick
+```
+
+Available routing choices are `balanced`, `quota`, `priority`, and `round-robin`.
+No fallback model is selected by default. A capacity error preserves the selected
+model and account unless you have enabled a fallback. Setting `retry_attempts` to
+zero disables automatic capacity retries.
+
+Project preferences can live in `.relay.toml`, under `[settings]` or
+`[profiles.NAME]`. Existing `.codex-accounts.toml` files are also supported. Native Codex
+profiles still go after the separator: `relay run -- -p work`.
+
+## Checks and extras
+
+```sh
+relay check
+relay doctor --self-test --backup
+relay doctor --restore-backup
+relay events --limit 30
+relay usage
+relay runtime list
+relay runtime preflight /path/to/candidate/codex
+relay runtime use installed
+relay menubar
+relay group save daily ~/projects/website ~/projects/api
+relay group start daily
+```
+
+Restore requires stopped Relay sessions and preserves a copy of the replaced
+database. It does not change Keychain logins. Usage forecasts are estimates based
+on local observations. Groups currently start separate tasks in saved folders;
+they do not restore a whole previous workspace.

package/docs/publishing.md

@@ -0,0 +1,56 @@
+# Sharing Relay
+
+## GitHub and npx
+
+The GitHub repository is enough for friends to install or try Relay:
+
+```sh
+npm install -g github:blackspider-ops/relay#v0.4.1
+npx --yes github:blackspider-ops/relay#v0.4.1 --version
+```
+
+`npx` runs packages. It is not a separate publishing service. Publishing the
+`relay-codex` package on npm would also make `npx relay-codex` available.
+
+## Publish on npm
+
+Only a maintainer needs to do this:
+
+```sh
+npm login
+npm test
+npm run check
+npm pack --dry-run
+npm publish --access public
+```
+
+Use an npm account with publishing access and two-factor authentication, or the
+supported trusted-publishing setup. Package-name availability is checked again at
+publication; the GitHub repository does not reserve the npm name.
+
+After publishing, friends can use:
+
+```sh
+npx relay-codex setup --count 2
+npm install -g relay-codex
+```
+
+## Homebrew
+
+The repository includes a formula under `Formula/`. It can be installed from this
+repository as a personal tap; it does not need acceptance into Homebrew's main
+collection. The formula must point to a tagged release archive with its actual
+SHA-256 checksum.
+
+```sh
+brew tap blackspider-ops/relay https://github.com/blackspider-ops/relay
+brew install blackspider-ops/relay/relay-codex
+```
+
+For a new release, update the package and Python versions together, run the checks,
+tag it, upload the archive, then update the formula URL and checksum. Keep the
+previous release available for users who need to roll back.
+
+Official references: [npm publishing](https://docs.npmjs.com/creating-and-publishing-unscoped-public-packages),
+[npx](https://docs.npmjs.com/cli/v11/commands/npx/), and
+[Homebrew taps](https://docs.brew.sh/How-to-Create-and-Maintain-a-Tap).

package/docs/troubleshooting.md

@@ -0,0 +1,37 @@
+# Troubleshooting
+
+**“This conversation is open in another app.”**
+
+Close or unload that conversation in its original app before resuming it. Or fork
+it into a separate conversation. For a Relay-owned task, use
+`relay attach --takeover SESSION_ID`.
+
+**A session needs attention.**
+
+Run `relay status`, then `relay events`. Once the cause is resolved, use
+`relay restart SESSION_ID` if the worker stopped, or `relay retry SESSION_ID` if it
+is still running and you have reviewed the interrupted work.
+
+**Setup was interrupted.**
+
+Run the command again. Relay retries unfinished dependency installation. If Python
+is missing or too old, install it with `brew install python@3.13`.
+
+**An account needs another sign-in.**
+
+Move its live tasks to another account, then run `relay account reauth ACCOUNT`.
+Other accounts can keep working.
+
+**The terminal disconnected after a worker restart.**
+
+The background task may still be running. Check `relay status` and reattach with
+`relay attach SESSION_ID`. Automatic terminal reconnection across a full worker
+replacement is not guaranteed.
+
+**Something still seems wrong.**
+
+Run `relay doctor --self-test`. Include the Relay and Codex versions when reporting
+a bug. Do not post auth files, tokens, connection files, or private task prompts.
+
+Long runs, physical sleep/wake cycles, real revoked logins, and future Codex
+versions need broader live testing. The tests do not remove those limits.

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "relay-codex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.1",
+  "description": "Keep your Codex sessions moving between your own accounts.",
+  "license": "MIT",
+  "author": "blackspider-ops",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blackspider-ops/relay.git"
+  },
+  "homepage": "https://github.com/blackspider-ops/relay#readme",
+  "bugs": {
+    "url": "https://github.com/blackspider-ops/relay/issues"
+  },
+  "bin": {
+    "relay": "bin/relay.cjs"
+  },
+  "files": [
+    "bin/*.cjs",
+    "python/*.py",
+    "python/*.swift",
+    "python/*.lock",
+    "python/*.txt",
+    "tests/*.py",
+    "README.md",
+    "LICENSE",
+    "docs/*.md",
+    "assets/*.svg"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "darwin"
+  ],
+  "keywords": [
+    "codex",
+    "terminal",
+    "accounts",
+    "macos"
+  ],
+  "scripts": {
+    "test": "node --test tests/bootstrap.test.cjs",
+    "check": "node scripts/check-release.cjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/python/Menu.swift

@@ -0,0 +1,70 @@
+import AppKit
+
+final class MenuController: NSObject, NSApplicationDelegate {
+    var item: NSStatusItem!
+    var timer: Timer?
+    var busy = false
+    let command = CommandLine.arguments.count > 1 ? CommandLine.arguments[1] : (Bundle.main.object(forInfoDictionaryKey: "RelayCommand") as? String ?? "/usr/bin/false")
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        NSApp.setActivationPolicy(.accessory)
+        item = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+        item.button?.title = "Relay"
+        refresh()
+        timer = Timer.scheduledTimer(withTimeInterval: 30, repeats: true) { [weak self] _ in self?.refresh() }
+    }
+    @objc func refresh() {
+        if busy { return }; busy = true
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
+            let process = Process(); process.executableURL = URL(fileURLWithPath: self.command)
+            process.arguments = ["status", "--json"]
+            let pipe = Pipe(); process.standardOutput = pipe; process.standardError = FileHandle.nullDevice
+            var value: [String: Any] = [:]
+            do {
+                try process.run()
+                let bytes = pipe.fileHandleForReading.readDataToEndOfFile(); process.waitUntilExit()
+                value = (try? JSONSerialization.jsonObject(with: bytes)) as? [String: Any] ?? [:]
+            } catch { }
+            let result = value
+            DispatchQueue.main.async { self.busy = false; self.render(result) }
+        }
+    }
+    func render(_ value: [String: Any]) {
+        let sessions = value["sessions"] as? [[String: Any]] ?? []
+        let accounts = value["accounts"] as? [[String: Any]] ?? []
+        item.button?.title = "Relay \(sessions.count)"
+        let menu = NSMenu()
+        let heading = NSMenuItem(title: "\(sessions.count) sessions · \(accounts.count) accounts", action: nil, keyEquivalent: "")
+        menu.addItem(heading); menu.addItem(.separator())
+        for account in accounts {
+            let name = account["name"] as? String ?? "Account"
+            let primary = account["primary"] as? [String: Any]
+            let used = (primary?["usedPercent"] as? NSNumber)?.intValue
+            let remaining = used.map { "\(max(0,100-$0))% left" } ?? "usage unknown"
+            let enabled = account["enabled"] as? Bool ?? true
+            menu.addItem(NSMenuItem(title: "\(name): \(enabled ? remaining : "disabled")", action: nil, keyEquivalent: ""))
+        }
+        for session in sessions {
+            let name = session["name"] as? String ?? String((session["id"] as? String ?? "").prefix(10))
+            let state = session["state"] as? String ?? "unknown"
+            menu.addItem(NSMenuItem(title: "\(name) — \(state)", action: nil, keyEquivalent: ""))
+        }
+        menu.addItem(.separator())
+        let copy = NSMenuItem(title: "Copy dashboard command", action: #selector(copyDashboard), keyEquivalent: ""); copy.target=self; menu.addItem(copy)
+        let update = NSMenuItem(title: "Refresh allowance", action: #selector(refreshAllowance), keyEquivalent: ""); update.target=self; menu.addItem(update)
+        let reload = NSMenuItem(title: "Refresh menu", action: #selector(refresh), keyEquivalent: ""); reload.target=self; menu.addItem(reload)
+        let quit = NSMenuItem(title: "Quit menu", action: #selector(quitMenu), keyEquivalent: "q"); quit.target=self; menu.addItem(quit)
+        item.menu=menu
+    }
+    @objc func copyDashboard() {
+        NSPasteboard.general.clearContents(); NSPasteboard.general.setString("relay status --watch", forType: .string)
+    }
+    @objc func refreshAllowance() {
+        let process=Process(); process.executableURL=URL(fileURLWithPath:command);process.arguments=["refresh"]
+        process.standardOutput=FileHandle.nullDevice;process.standardError=FileHandle.nullDevice
+        try? process.run()
+    }
+    @objc func quitMenu() { NSApp.terminate(nil) }
+}
+let app=NSApplication.shared
+let delegate=MenuController(); app.delegate=delegate; app.run()