repowire
May the agents talk. Connect Claude Code, Opencode, Codex, Pi across projects, across machines and with your telegram
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Check it deeper on your machine
It has changed since its scan on 11 Nov 2026.
As a Claude Code plugin, install it and then ask Claude Code:
/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/prassanna-ravishankar/repowire with scanskillsafety
Or from a terminal, clone it and run it:
git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/prassanna-ravishankar/repowire'
It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.
Badge for your README
Markdown
[](/listings/prassanna-ravishankar--repowire)HTML
<a href="/listings/prassanna-ravishankar--repowire"><img src="/api/listings/prassanna-ravishankar--repowire/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
These steps run a script from the network that findsafeskills does not scan.
**Requirements:** macOS or Linux. Tmux is required for the default Claude Code workflow and Repowire-managed spawning/lifecycle, but not for pane-less Codex, OpenCode, or Pi connections. Python is not required.
**1. Install Repowire and wire your agents.**
brew install prassanna-ravishankar/repowire/repowire repowire setup
Or use the checksum-verified native installer:
curl -fsSL https://github.com/prassanna-ravishankar/repowire/releases/latest/download/install.sh | sh
The installer downloads a checksum-verified native binary from GitHub Releases.
**2. Open your normal agent CLIs.**
Use the tools directly; Repowire hooks into them after setup.
# tmux window 1 cd ~/projects/project-a && claude # tmux window 2 cd ~/projects/project-b && codex
**3. Check that both peers appeared.**
Claude Code registers on session start. Codex registers through App Server when its TUI thread opens, before the first prompt. Run:
repowire peer list
**4. Ask from one agent to the other.**
In `project-a`, tell your local agent:
Ask project-b what API endpoints they expose.
Your local agent invokes Repowire's `ask` MCP tool, the second agent receives the question, and the reply comes back as an `ack` notification. Repowire is the mesh and tool surface around the agents, not a standalone chat UI. The same pattern works across Claude Code, Codex, OpenCode, and Pi when those runtimes are installed.
https://github.com/user-attachments/assets/a9eab9c4-8aea-4dbb-8914-e998311b6d14
You can also spawn peers through Repowire:
repowire peer new ~/projects/project-a repowire peer new ~/projects/project-b --backend codex --profile fast
For durable recurring workers, scaffold a repo-local agent folder and target it from jobs:
repowire agents create daily-brief --backend codex repowire jobs create "Daily brief" --path .repowire/agents/daily-brief --backend codex --cron "@daily" --prompt "Prepare the brief."
**Reach your sessions remotely from Claude or ChatGPT.**
Enable the relay. Your relay secret is written to `~/.repowire/config.yaml` under `relay.api_key`.
repowire setup --relay
In Claude Code, install the remote plugin, then authenticate it in `/mcp`:
/plugin marketplace add prassanna-ravishankar/repowire /plugin install repowire-remote@repowire
In Claude.ai, ChatGPT, or another remote MCP client, add `https://relay.repowire.io/mcp` as a custom connector with OAuth. Enter the relay secret on the relay's consent page; the client gets its own scoped credentials, never the secret.
Then, from the remote chat:
Which of my agents are online? Ask project-b what API endpoints they expose and show me the reply.
The client finds the agent with `list_agents`, sends the question with `ask_agent`, and collects the answer with `get_reply`. See [Relay MCP](docs/reference/relay-mcp.md) for scopes, expiry, and limits.
Full docs: [docs.repowire.io](https://docs.repowire.io).
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
.claude-plugin/marketplace.json · Manifest · 19 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.
- {
- "name": "repowire",
- "owner": {
- "name": "Prassanna Ravishankar",
- "url": "https://github.com/prassanna-ravishankar/repowire"
- },
- "plugins": [
- {
- "name": "repowire",
- "source": ".",
- "description": "Repowire mesh usage skills: cross-agent review/plan, delegate, patterns, and install/update — backend-agnostic, parameterised on the agent you choose."
- },
- {
- "name": "repowire-remote",
- "source": "./plugins/repowire-remote",
- "description": "Talk to local agents from remote MCP clients, with OAuth and skills for delegation, review, and planning."
- }
- ]
- }
README.md · README · 392 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.
- <div align="center">
- <picture>
- <source srcset="https://raw.githubusercontent.com/prassanna-ravishankar/repowire/main/images/logo-dark.webp" media="(prefers-color-scheme: dark)" width="150" height="150" />
- <img src="https://raw.githubusercontent.com/prassanna-ravishankar/repowire/main/images/logo-light.webp" alt="Repowire Logo" width="150" height="150" />
- </picture>
- <h1>Repowire</h1>
- <p>Let your coding agents talk to each other.</p>
- [](https://github.com/prassanna-ravishankar/repowire/releases)
- [](https://github.com/prassanna-ravishankar/repowire/actions/workflows/ci.yml)
- [](daemon-go/go.mod)
- [](LICENSE)
- [](https://docs.repowire.io/)
- </div>
- Repowire connects the coding agents you already have open. Claude Code in one repo, Codex in another, a dashboard in your browser, Telegram on your phone: Repowire gives them names and lets them pass messages without copy-paste.
- It is a local control layer for multi-agent work: ask another agent a question, send a quick update, schedule a reminder, or run one session as the coordinator.
- Use it when:
- - One repo needs a concrete answer from an agent already working in another repo.
- - You want a personal orchestrator session to dispatch tasks, collect status, or keep reviews moving.
- - You want to monitor or nudge agent work from your phone or browser.
- - A session should wake itself or another peer later with a scheduled check-in.
- Repowire runs locally by default through a daemon on your machine. The hosted relay is optional and uses outbound connections for remote dashboard and remote MCP access.
- ## Quickstart
- **Requirements:** macOS or Linux. Tmux is required for the default Claude Code
- workflow and Repowire-managed spawning/lifecycle, but not for pane-less Codex,
- OpenCode, or Pi connections. Python is not required.
- **1. Install Repowire and wire your agents.**
- ```bash
- brew install prassanna-ravishankar/repowire/repowire
- repowire setup
- ```
- Or use the checksum-verified native installer:
- ```bash
- curl -fsSL https://github.com/prassanna-ravishankar/repowire/releases/latest/download/install.sh | sh
- ```
- The installer downloads a checksum-verified native binary from GitHub Releases.
- **2. Open your normal agent CLIs.**
- Use the tools directly; Repowire hooks into them after setup.
- ```bash
- # tmux window 1
- cd ~/projects/project-a && claude
- # tmux window 2
- cd ~/projects/project-b && codex
- ```
- **3. Check that both peers appeared.**
- Claude Code registers on session start. Codex registers through App Server when
- its TUI thread opens, before the first prompt. Run:
- ```bash
- repowire peer list
- ```
- **4. Ask from one agent to the other.**
- In `project-a`, tell your local agent:
- ```text
- Ask project-b what API endpoints they expose.
- ```
- Your local agent invokes Repowire's `ask` MCP tool, the second agent receives the question, and the reply comes back as an `ack` notification. Repowire is the mesh and tool surface around the agents, not a standalone chat UI. The same pattern works across Claude Code, Codex, OpenCode, and Pi when those runtimes are installed.
- https://github.com/user-attachments/assets/a9eab9c4-8aea-4dbb-8914-e998311b6d14
- You can also spawn peers through Repowire:
- ```bash
- repowire peer new ~/projects/project-a
- repowire peer new ~/projects/project-b --backend codex --profile fast
- ```
- For durable recurring workers, scaffold a repo-local agent folder and target it
- from jobs:
- ```bash
- repowire agents create daily-brief --backend codex
- repowire jobs create "Daily brief" --path .repowire/agents/daily-brief --backend codex --cron "@daily" --prompt "Prepare the brief."
- ```
- **Reach your sessions remotely from Claude or ChatGPT.**
- Enable the relay. Your relay secret is written to `~/.repowire/config.yaml` under `relay.api_key`.
- ```bash
- repowire setup --relay
- ```
- In Claude Code, install the remote plugin, then authenticate it in `/mcp`:
- ```text
- /plugin marketplace add prassanna-ravishankar/repowire
- /plugin install repowire-remote@repowire
- ```
- In Claude.ai, ChatGPT, or another remote MCP client, add `https://relay.repowire.io/mcp` as a custom connector with OAuth. Enter the relay secret on the relay's consent page; the client gets its own scoped credentials, never the secret.
- Then, from the remote chat:
- ```text
- Which of my agents are online? Ask project-b what API endpoints they expose and show me the reply.
- ```
- The client finds the agent with `list_agents`, sends the question with `ask_agent`, and collects the answer with `get_reply`. See [Relay MCP](docs/reference/relay-mcp.md) for scopes, expiry, and limits.
- Full docs: [docs.repowire.io](https://docs.repowire.io).
- ## What You Get
- - **Agent-to-agent asks**: Non-blocking questions with explicit `ack` replies and reminder injection until a thread is closed.
- - **Human control surfaces**: Browser dashboard, Telegram, and Slack can route messages as service peers.
- - **Human inbox**: you are a peer too. Notifies, asks, and replies sent to you are stored in a durable inbox, pushed to Telegram with receipts, and readable with `repowire inbox`.
- - **Durable jobs**: Track one-off and recurring work through CLI/MCP, with dashboard visibility and controls for run, retry, and cancel.
- - **Orchestrator pattern**: A dedicated peer can dispatch work, check status, coordinate reviews, and keep a queue moving.
- - **Scheduled wake-ups**: Send a future notification or ask to yourself, another peer, or an orchestrator.
- - **Git trailers**: Agent commits carry `Repowire-Thread` and `Repowire-Session` trailers; `repowire why` replays the conversations behind a commit.
- - **Optional relay**: Reach the dashboard and your agents remotely without opening inbound ports. The [remote MCP plugin](docs/reference/relay-mcp.md) adds OAuth-authenticated agent conversations, delegation, and replies from compatible clients.
- ## How It Works
- All peers connect to a local daemon. The daemon keeps the registry, routes asks/notifies, tracks open asks, stores durable jobs, runs schedules, and feeds the dashboard timeline.
- <p align="center">
- <img src="images/repowire-arch.webp" alt="Repowire architecture" width="700" />
- </p>
- The stable public surface is peers, circles, asks, notifications, broadcasts, schedules, and the `/jobs` tracked-work API exposed through CLI and MCP JSON tools. The v0.14 direction is session-native: sessions become the durable unit of work, while peers remain the live runtime executors. The current dashboard shows the selected peer/session view, merges Claude transcript history where available with realtime events, and is moving toward broader session commands for controls like resume, scheduling, approvals, and future backend/model changes.
- Transport notes:
- - Claude Code uses hooks plus MCP, with its authenticated native session inbox for delivery. Claude Code 2.1.224+ is required.
- - Native session APIs connect through runtime-side bridges; routing remains daemon-owned and transport-neutral.
- - Codex uses an App Server bridge plus MCP; daemon-minted thread certificates preserve identity across soft retirement, while tmux remains optional lifecycle/placement support.
- - OpenCode uses a TypeScript plugin plus WebSocket; its per-session identity and certificate survive plugin reconnects.
- - Pi uses the Repowire extension path when detected by setup, with the same per-session reconnect protection.
- - Claude Code's Channel bridge / ACP delivery is experimental and opt-in.
- - Relay is optional remote access, not a requirement for local routing.
- ## Supported Agents and Surfaces
- | Agent runtime | Connection path |
- | --- | --- |
- | Claude Code | Hooks + MCP + native session inbox; optional experimental channel/ACP |
- | Codex | App Server threads + MCP |
- | OpenCode | Plugin + WebSocket |
- | Pi | Native Repowire extension + WebSocket |
- | Human or service surface | Role in the mesh |
- | --- | --- |
- | Dashboard | Browser control surface at `localhost:8377/dashboard` or through relay |
- | Telegram | Phone control surface and notification target |
- | Slack | Team chat control surface |
- | Orchestrator peer | Long-running coordinator that dispatches and reviews work |
- | Relay dashboard | Optional remote dashboard and remote MCP access |
- `repowire setup` auto-detects installed runtimes and wires the supported transports it finds.
- ## How It Compares
- The agent-orchestration space is moving fast. Most projects cluster around a few shapes:
- - **Worktree/task runners**: [Claude Squad](https://github.com/smtg-ai/claude-squad), [Vibe Kanban](https://github.com/BloopAI/vibe-kanban), and [dmux](https://dmux.ai/) help launch and review many isolated agent workspaces.
- - **Deterministic schedulers**: [Bernstein](https://github.com/sipyourdrink-ltd/bernstein) decomposes goals, runs agents in parallel worktrees, verifies, and merges passing work.
- - **Hierarchical swarms**: [multi-agent-shogun](https://github.com/yohey-w/multi-agent-shogun) defines manager/worker roles and routes tasks through tmux, files, or role-specific protocols.
- - **Agent IDEs and workflow systems**: [HumanLayer/CodeLayer](https://github.com/humanlayer/humanlayer) focuses on planning, review, team workflows, and richer agent workspaces.
- Repowire sits in a different slot: it is a live mesh and control plane for agent sessions you already have running. It does not try to be the scheduler that decomposes every goal, the kanban board that owns every branch, or the merge gate that lands code. It gives your existing terminals, dashboard, Telegram, Slack, and orchestrator session a shared address book, message lifecycle, schedule queue, and local session timeline.
- ## Common Workflows
- ### Ask another repo
- Project A needs the real API shape from Project B. Ask `project-b`; the peer answers from its live checkout, not stale docs. See [multi-repo coordination](https://docs.repowire.io/use/workflows/multi-repo/).
- ### Drive from phone or dashboard
- Send work to a peer from Telegram, Slack, or the dashboard, then receive progress updates from agents as notifications. Telegram and Slack human messages open tracked asks by default; use their notify/FYI commands for fire-and-forget nudges. See [mobile mesh management](https://docs.repowire.io/use/workflows/mobile-mesh/).
- ### Coordinate with an orchestrator
- Run one session as the orchestrator. It can dispatch to project peers, ask for status, review PRs, and wake itself later. See [orchestrator coordination](https://docs.repowire.io/use/workflows/orchestrator-coordination/).
- ### Wake a peer later
- Schedule a reminder, check-in, or future ask:
- ```bash
- repowire schedule self 10m "check CI"
- repowire schedule create orchestrator 1h "handoff" --from-peer project-a --kind ask
- ```
- ### See why a commit happened
- Claude Code commits made through Repowire record the ask threads they closed as git trailers. Replay them:
- ```bash
- repowire why # HEAD
- repowire why abc1234 # any commit
- ```
- ### Remote access
- Enable the hosted relay when you want remote dashboard or remote MCP access to a machine's agents. Agents on different machines do not message each other:
- ```bash
- repowire setup --relay
- ```
- ## Dashboard
- <p align="center">
- <img src="images/repowire-hosted-2.png" alt="Repowire dashboard peer overview" width="700" />
- </p>
- The dashboard shows peers, status, descriptions, chat turns, tool calls, attachments, durable jobs, and the selected peer/session timeline. Its non-destructive `Fork to…` control can start a sibling backend in the same project and circle without stopping the current peer; backend-native conversation history is not copied. For Claude Code peers, the timeline can merge transcript history with realtime events; other backends contribute realtime events as their transports report them.
- <p align="center">
- <img src="images/dashboard-fork-backend.png" alt="Dashboard peer header with the non-destructive Fork to backend control" width="700" />
- </p>
- Run it locally at:
- ```text
- http://localhost:8377/dashboard
- ```
- With relay enabled, use:
- ```text
- https://repowire.io/dashboard
- ```
- ## Core Commands
- ```bash
- repowire setup # install runtime transports/service + localhost MCP identity shim
- repowire setup --update-checks # let status/doctor report available updates
- repowire update # explicit package upgrade + hook reinstall + daemon restart
- repowire status # show installed components and daemon status
- repowire doctor # run diagnostics
- repowire service restart # restart daemon; preserve Codex sessions
- repowire service restart bridge # restart the Codex adapter; Codex sessions keep running
- repowire peer list # list mesh peers
- repowire peer new PATH [--profile P] # spawn a peer in tmux
- repowire schedule self 10m "check CI" # wake this peer later
- repowire telegram start # manually run Telegram against another daemon
- repowire slack start # manually run Slack against another daemon
- ```
- The daemon uses `~/.repowire/state.db` for durable local state. On first startup
- after install or update, it applies SQLite migrations and imports legacy
- `schedules.json`, `events.json`, and `sessions.json` once while leaving those
- files in place for downgrade/export compatibility. Migrated state is written to
- SQLite, and `repowire doctor` reports the SQLite schema, integrity, and import
- status.
- See the full [CLI reference](https://docs.repowire.io/reference/cli/) and [MCP tools reference](https://docs.repowire.io/reference/mcp-tools/).
- ## Routing
- Repowire is a router whose default strategy is static: an ask goes to the peer it names, and a named peer is never overridden. Other strategies are opt-in. With `routing.strategy` set to an arm (for example `jev-attested`), an ask that names no peer is routed to the arm's pick. The pick passes the same circle and addressability checks, and the sender's `fallback_to` is used if the arm cannot choose. `routing.record` and `routing.shadow_arms` record decisions and run arms beside named asks for offline comparison with `repowire route replay`. See [routing configuration](docs/reference/configuration.md#routing).
- ```yaml
- routing:
- strategy: static # default; or an arm name to route asks that name no peer
- ```
- ## Configuration and Security
- Config lives at `~/.repowire/config.yaml`.
- ```yaml
- daemon:
- host: "127.0.0.1"
- port: 8377
- auth_token: "rw_local_..."
- mcp_http:
- enabled: true
- bind: "localhost-only"
- require_auth: true
- allow_dangerous_tools: false
- spawn:
- commands:
- claude-code: "claude --dangerously-skip-permissions"
- codex: "codex --dangerously-bypass-approvals-and-sandbox"
- pi: "pi"
- profiles:
- codex:
- fast:
- args: ["--model", "gpt-5-mini"]
- allowed_paths: [~/git, ~/projects]
- updates:
- check_enabled: false
- relay:
- enabled: true
- url: "wss://repowire.io"
- api_key: "rw_..."
- ```
- Update checks are off by default. If enabled with `repowire setup --update-checks`, `repowire status` and `repowire doctor` may report that a newer release is available, but they do not rewrite hooks or restart services. Use `repowire update` when you want to upgrade explicitly; Homebrew installs delegate that command to `brew upgrade`. Updates restart the routing daemon but preserve a live Codex bridge, and never restart Codex's App Server, so active Codex sessions remain running.
- Security defaults:
- - Local daemon binds to `127.0.0.1`.
- - Relay is opt-in and uses outbound WebSocket.
- - WebSocket and local HTTP auth are available through `daemon.auth_token`.
- - MCP tools are implemented by the Go daemon at a localhost-only, bearer-authenticated `/mcp`; agent runtimes reach it through a thin stdio identity shim, and the relay tunnel rejects that local endpoint. The relay has its own scoped [remote MCP endpoint](docs/reference/relay-mcp.md) with OAuth.
- - Spawn requires explicit command and path allowlists.
- - Experimental channel/ACP transport is opt-in.
- ## Developing From Source
- ```bash
- git clone https://github.com/prassanna-ravishankar/repowire
- cd repowire
- cd web && npm ci && npm run build && cd ..
- mkdir -p bin
- (cd daemon-go && go build -o ../bin/repowire .)
- ./bin/repowire setup --non-interactive
- ```
- Hooks and the MCP identity shim run the binary recorded by setup, not an
- arbitrary binary elsewhere in your checkout. Rebuild that binary after native
- changes, then restart the daemon service:
- ```bash
- (cd daemon-go && go build -o ../bin/repowire .)
- ./bin/repowire setup --non-interactive # rewrites hooks/MCP/service to this build
- ./bin/repowire service restart # enough when only daemon code changed
- ```
- If service management fails, use `repowire service status` first. Raw `launchctl` on macOS or `systemctl --user` on Linux are fallback troubleshooting tools.
- Codex (0.158+) starts and upgrades its own shared App Server; the Repowire bridge only attaches to its Unix socket. Repowire never launches Codex, so macOS attributes privacy prompts for Codex's tools to your terminal. Setup removes the App Server LaunchAgent that earlier releases installed; open Codex sessions reconnect to Codex's server with their conversations intact.
- ## References
- - [Start](https://docs.repowire.io/start/)
- - [Architecture](https://docs.repowire.io/operate/architecture/)
- - [MCP tools](https://docs.repowire.io/reference/mcp-tools/)
- - [CLI](https://docs.repowire.io/reference/cli/)
- - [Use](https://docs.repowire.io/use/)
- - [Features](https://docs.repowire.io/use/features/)
- - [Troubleshooting](https://docs.repowire.io/troubleshooting/)
- - [Compare](https://docs.repowire.io/start/compare/)
- ## Uninstall
- ```bash
- repowire uninstall
- rm -f ~/.local/bin/repowire
- rm -rf ~/.local/share/repowire
- ```
- `repowire uninstall` removes hooks, MCP entries, channel transport config, OpenCode plugin files, and the daemon service. It does not automatically remove `~/.repowire/`, which contains local config, events, attachments, and relay keys.
- ## Contributing
- See [CONTRIBUTING.md](CONTRIBUTING.md). Before opening a PR, run the advisory repo-hygiene
- checklist:
- ```bash
- scripts/pre-pr-hygiene.sh
- ```
- It is an opt-in prompt for docs, README, and agent-instruction follow-ups, not a
- mandatory hook.
- ## License
- MIT
install.sh · Bundled script · 77 lines · 1 finding marked
- #!/bin/sh
- # Repowire native installer — curl -fsSL https://github.com/prassanna-ravishankar/repowire/releases/latest/download/install.sh | sh
- Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
- Line 2 on GitHub
- set -eu
- repo="prassanna-ravishankar/repowire"
- os=$(uname -s)
- arch=$(uname -m)
- case "$os" in
- Darwin) os=darwin ;;
- Linux) os=linux ;;
- *) echo "Error: Repowire supports macOS and Linux (got $os)." >&2; exit 1 ;;
- esac
- case "$arch" in
- x86_64|amd64) arch=amd64 ;;
- arm64|aarch64) arch=arm64 ;;
- *) echo "Error: unsupported architecture $arch." >&2; exit 1 ;;
- esac
- if ! command -v curl >/dev/null 2>&1; then
- echo "Error: curl is required." >&2
- exit 1
- fi
- version=${REPOWIRE_VERSION:-}
- if [ -z "$version" ]; then
- version=$(curl -fsSL -H "Accept: application/vnd.github+json" \
- "https://api.github.com/repos/$repo/releases/latest" \
- | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
- | head -n 1)
- fi
- if [ -z "$version" ]; then
- echo "Error: could not determine the latest Repowire release." >&2
- exit 1
- fi
- case "$version" in v*) ;; *) version="v$version" ;; esac
- asset="repowire_${version#v}_${os}_${arch}.tar.gz"
- base="https://github.com/$repo/releases/download/$version"
- tmp=$(mktemp -d "${TMPDIR:-/tmp}/repowire.XXXXXX")
- trap 'rm -rf "$tmp"' EXIT HUP INT TERM
- echo "Installing Repowire $version for $os/$arch..."
- curl -fsSL "$base/$asset" -o "$tmp/$asset"
- curl -fsSL "$base/checksums.txt" -o "$tmp/checksums.txt"
- expected=$(awk -v name="$asset" '$2 == name {print $1}' "$tmp/checksums.txt")
- if [ -z "$expected" ]; then
- echo "Error: release checksum for $asset is missing." >&2
- exit 1
- fi
- if command -v sha256sum >/dev/null 2>&1; then
- actual=$(sha256sum "$tmp/$asset" | awk '{print $1}')
- else
- actual=$(shasum -a 256 "$tmp/$asset" | awk '{print $1}')
- fi
- if [ "$actual" != "$expected" ]; then
- echo "Error: checksum mismatch for $asset." >&2
- exit 1
- fi
- root=${REPOWIRE_INSTALL_DIR:-"$HOME/.local/share/repowire"}
- bin_dir=${REPOWIRE_BIN_DIR:-"$HOME/.local/bin"}
- target="$root/$version"
- mkdir -p "$target" "$bin_dir"
- tar -xzf "$tmp/$asset" -C "$target"
- chmod +x "$target/repowire"
- ln -sfn "$target/repowire" "$bin_dir/repowire"
- case ":$PATH:" in
- *":$bin_dir:"*) ;;
- *) echo "Note: add $bin_dir to PATH." ;;
- esac
- if ! command -v tmux >/dev/null 2>&1; then
- echo "Warning: tmux is not installed (needed for peer spawning)."
- fi
- echo "Installed Repowire $version to $target."
- "$target/repowire" setup "$@"
web/components/marketing/links.ts · Bundled script · 15 lines · 1 finding marked
- // Shared external link targets for the marketing site.
- //
- // The hosted dashboard is served by the relay at relay.repowire.io, not at
- // repowire.io/dashboard (that path is the local daemon's dashboard). Marketing
- // links point straight at the relay so visitors don't hit the local-style path
- // and rely on a client-side hostname redirect.
- export const RELAY_DASHBOARD_URL = "https://relay.repowire.io/dashboard";
- export const GITHUB_URL = "https://github.com/prassanna-ravishankar/repowire";
- export const DOCS_URL = "https://docs.repowire.io";
- export const RELEASES_URL = `${GITHUB_URL}/releases`;
- // Install commands, as the README's quickstart gives them.
- export const BREW_INSTALL = "brew install prassanna-ravishankar/repowire/repowire";
- export const CURL_INSTALL = "curl -fsSL https://github.com/prassanna-ravishankar/repowire/releases/latest/download/install.sh | sh";
- Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
- Line 15 on GitHub
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.