Skip to content
Back to search

repowire

MarketplaceWorks with Claude CodeGitHub

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.

Checked today

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
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/prassanna-ravishankar--repowire/badge.svg)](/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.

  1. {
  2. "name": "repowire",
  3. "owner": {
  4. "name": "Prassanna Ravishankar",
  5. "url": "https://github.com/prassanna-ravishankar/repowire"
  6. },
  7. "plugins": [
  8. {
  9. "name": "repowire",
  10. "source": ".",
  11. "description": "Repowire mesh usage skills: cross-agent review/plan, delegate, patterns, and install/update — backend-agnostic, parameterised on the agent you choose."
  12. },
  13. {
  14. "name": "repowire-remote",
  15. "source": "./plugins/repowire-remote",
  16. "description": "Talk to local agents from remote MCP clients, with OAuth and skills for delegation, review, and planning."
  17. }
  18. ]
  19. }
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.

  1. <div align="center">
  2. <picture>
  3. <source srcset="https://raw.githubusercontent.com/prassanna-ravishankar/repowire/main/images/logo-dark.webp" media="(prefers-color-scheme: dark)" width="150" height="150" />
  4. <img src="https://raw.githubusercontent.com/prassanna-ravishankar/repowire/main/images/logo-light.webp" alt="Repowire Logo" width="150" height="150" />
  5. </picture>
  6. <h1>Repowire</h1>
  7. <p>Let your coding agents talk to each other.</p>
  8. [![Release](https://img.shields.io/github/v/release/prassanna-ravishankar/repowire)](https://github.com/prassanna-ravishankar/repowire/releases)
  9. [![CI](https://github.com/prassanna-ravishankar/repowire/actions/workflows/ci.yml/badge.svg)](https://github.com/prassanna-ravishankar/repowire/actions/workflows/ci.yml)
  10. [![Go](https://img.shields.io/github/go-mod/go-version/prassanna-ravishankar/repowire?filename=daemon-go%2Fgo.mod)](daemon-go/go.mod)
  11. [![License](https://img.shields.io/github/license/prassanna-ravishankar/repowire)](LICENSE)
  12. [![Docs](https://img.shields.io/badge/docs-repowire.io-2563EB)](https://docs.repowire.io/)
  13. </div>
  14. 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.
  15. 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.
  16. Use it when:
  17. - One repo needs a concrete answer from an agent already working in another repo.
  18. - You want a personal orchestrator session to dispatch tasks, collect status, or keep reviews moving.
  19. - You want to monitor or nudge agent work from your phone or browser.
  20. - A session should wake itself or another peer later with a scheduled check-in.
  21. 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.
  22. ## Quickstart
  23. **Requirements:** macOS or Linux. Tmux is required for the default Claude Code
  24. workflow and Repowire-managed spawning/lifecycle, but not for pane-less Codex,
  25. OpenCode, or Pi connections. Python is not required.
  26. **1. Install Repowire and wire your agents.**
  27. ```bash
  28. brew install prassanna-ravishankar/repowire/repowire
  29. repowire setup
  30. ```
  31. Or use the checksum-verified native installer:
  32. ```bash
  33. curl -fsSL https://github.com/prassanna-ravishankar/repowire/releases/latest/download/install.sh | sh
  34. ```
  35. The installer downloads a checksum-verified native binary from GitHub Releases.
  36. **2. Open your normal agent CLIs.**
  37. Use the tools directly; Repowire hooks into them after setup.
  38. ```bash
  39. # tmux window 1
  40. cd ~/projects/project-a && claude
  41. # tmux window 2
  42. cd ~/projects/project-b && codex
  43. ```
  44. **3. Check that both peers appeared.**
  45. Claude Code registers on session start. Codex registers through App Server when
  46. its TUI thread opens, before the first prompt. Run:
  47. ```bash
  48. repowire peer list
  49. ```
  50. **4. Ask from one agent to the other.**
  51. In `project-a`, tell your local agent:
  52. ```text
  53. Ask project-b what API endpoints they expose.
  54. ```
  55. 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.
  56. https://github.com/user-attachments/assets/a9eab9c4-8aea-4dbb-8914-e998311b6d14
  57. You can also spawn peers through Repowire:
  58. ```bash
  59. repowire peer new ~/projects/project-a
  60. repowire peer new ~/projects/project-b --backend codex --profile fast
  61. ```
  62. For durable recurring workers, scaffold a repo-local agent folder and target it
  63. from jobs:
  64. ```bash
  65. repowire agents create daily-brief --backend codex
  66. repowire jobs create "Daily brief" --path .repowire/agents/daily-brief --backend codex --cron "@daily" --prompt "Prepare the brief."
  67. ```
  68. **Reach your sessions remotely from Claude or ChatGPT.**
  69. Enable the relay. Your relay secret is written to `~/.repowire/config.yaml` under `relay.api_key`.
  70. ```bash
  71. repowire setup --relay
  72. ```
  73. In Claude Code, install the remote plugin, then authenticate it in `/mcp`:
  74. ```text
  75. /plugin marketplace add prassanna-ravishankar/repowire
  76. /plugin install repowire-remote@repowire
  77. ```
  78. 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.
  79. Then, from the remote chat:
  80. ```text
  81. Which of my agents are online? Ask project-b what API endpoints they expose and show me the reply.
  82. ```
  83. 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.
  84. Full docs: [docs.repowire.io](https://docs.repowire.io).
  85. ## What You Get
  86. - **Agent-to-agent asks**: Non-blocking questions with explicit `ack` replies and reminder injection until a thread is closed.
  87. - **Human control surfaces**: Browser dashboard, Telegram, and Slack can route messages as service peers.
  88. - **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`.
  89. - **Durable jobs**: Track one-off and recurring work through CLI/MCP, with dashboard visibility and controls for run, retry, and cancel.
  90. - **Orchestrator pattern**: A dedicated peer can dispatch work, check status, coordinate reviews, and keep a queue moving.
  91. - **Scheduled wake-ups**: Send a future notification or ask to yourself, another peer, or an orchestrator.
  92. - **Git trailers**: Agent commits carry `Repowire-Thread` and `Repowire-Session` trailers; `repowire why` replays the conversations behind a commit.
  93. - **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.
  94. ## How It Works
  95. 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.
  96. <p align="center">
  97. <img src="images/repowire-arch.webp" alt="Repowire architecture" width="700" />
  98. </p>
  99. 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.
  100. Transport notes:
  101. - Claude Code uses hooks plus MCP, with its authenticated native session inbox for delivery. Claude Code 2.1.224+ is required.
  102. - Native session APIs connect through runtime-side bridges; routing remains daemon-owned and transport-neutral.
  103. - Codex uses an App Server bridge plus MCP; daemon-minted thread certificates preserve identity across soft retirement, while tmux remains optional lifecycle/placement support.
  104. - OpenCode uses a TypeScript plugin plus WebSocket; its per-session identity and certificate survive plugin reconnects.
  105. - Pi uses the Repowire extension path when detected by setup, with the same per-session reconnect protection.
  106. - Claude Code's Channel bridge / ACP delivery is experimental and opt-in.
  107. - Relay is optional remote access, not a requirement for local routing.
  108. ## Supported Agents and Surfaces
  109. | Agent runtime | Connection path |
  110. | --- | --- |
  111. | Claude Code | Hooks + MCP + native session inbox; optional experimental channel/ACP |
  112. | Codex | App Server threads + MCP |
  113. | OpenCode | Plugin + WebSocket |
  114. | Pi | Native Repowire extension + WebSocket |
  115. | Human or service surface | Role in the mesh |
  116. | --- | --- |
  117. | Dashboard | Browser control surface at `localhost:8377/dashboard` or through relay |
  118. | Telegram | Phone control surface and notification target |
  119. | Slack | Team chat control surface |
  120. | Orchestrator peer | Long-running coordinator that dispatches and reviews work |
  121. | Relay dashboard | Optional remote dashboard and remote MCP access |
  122. `repowire setup` auto-detects installed runtimes and wires the supported transports it finds.
  123. ## How It Compares
  124. The agent-orchestration space is moving fast. Most projects cluster around a few shapes:
  125. - **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.
  126. - **Deterministic schedulers**: [Bernstein](https://github.com/sipyourdrink-ltd/bernstein) decomposes goals, runs agents in parallel worktrees, verifies, and merges passing work.
  127. - **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.
  128. - **Agent IDEs and workflow systems**: [HumanLayer/CodeLayer](https://github.com/humanlayer/humanlayer) focuses on planning, review, team workflows, and richer agent workspaces.
  129. 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.
  130. ## Common Workflows
  131. ### Ask another repo
  132. 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/).
  133. ### Drive from phone or dashboard
  134. 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/).
  135. ### Coordinate with an orchestrator
  136. 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/).
  137. ### Wake a peer later
  138. Schedule a reminder, check-in, or future ask:
  139. ```bash
  140. repowire schedule self 10m "check CI"
  141. repowire schedule create orchestrator 1h "handoff" --from-peer project-a --kind ask
  142. ```
  143. ### See why a commit happened
  144. Claude Code commits made through Repowire record the ask threads they closed as git trailers. Replay them:
  145. ```bash
  146. repowire why # HEAD
  147. repowire why abc1234 # any commit
  148. ```
  149. ### Remote access
  150. 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:
  151. ```bash
  152. repowire setup --relay
  153. ```
  154. ## Dashboard
  155. <p align="center">
  156. <img src="images/repowire-hosted-2.png" alt="Repowire dashboard peer overview" width="700" />
  157. </p>
  158. 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.
  159. <p align="center">
  160. <img src="images/dashboard-fork-backend.png" alt="Dashboard peer header with the non-destructive Fork to backend control" width="700" />
  161. </p>
  162. Run it locally at:
  163. ```text
  164. http://localhost:8377/dashboard
  165. ```
  166. With relay enabled, use:
  167. ```text
  168. https://repowire.io/dashboard
  169. ```
  170. ## Core Commands
  171. ```bash
  172. repowire setup # install runtime transports/service + localhost MCP identity shim
  173. repowire setup --update-checks # let status/doctor report available updates
  174. repowire update # explicit package upgrade + hook reinstall + daemon restart
  175. repowire status # show installed components and daemon status
  176. repowire doctor # run diagnostics
  177. repowire service restart # restart daemon; preserve Codex sessions
  178. repowire service restart bridge # restart the Codex adapter; Codex sessions keep running
  179. repowire peer list # list mesh peers
  180. repowire peer new PATH [--profile P] # spawn a peer in tmux
  181. repowire schedule self 10m "check CI" # wake this peer later
  182. repowire telegram start # manually run Telegram against another daemon
  183. repowire slack start # manually run Slack against another daemon
  184. ```
  185. The daemon uses `~/.repowire/state.db` for durable local state. On first startup
  186. after install or update, it applies SQLite migrations and imports legacy
  187. `schedules.json`, `events.json`, and `sessions.json` once while leaving those
  188. files in place for downgrade/export compatibility. Migrated state is written to
  189. SQLite, and `repowire doctor` reports the SQLite schema, integrity, and import
  190. status.
  191. See the full [CLI reference](https://docs.repowire.io/reference/cli/) and [MCP tools reference](https://docs.repowire.io/reference/mcp-tools/).
  192. ## Routing
  193. 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).
  194. ```yaml
  195. routing:
  196. strategy: static # default; or an arm name to route asks that name no peer
  197. ```
  198. ## Configuration and Security
  199. Config lives at `~/.repowire/config.yaml`.
  200. ```yaml
  201. daemon:
  202. host: "127.0.0.1"
  203. port: 8377
  204. auth_token: "rw_local_..."
  205. mcp_http:
  206. enabled: true
  207. bind: "localhost-only"
  208. require_auth: true
  209. allow_dangerous_tools: false
  210. spawn:
  211. commands:
  212. claude-code: "claude --dangerously-skip-permissions"
  213. codex: "codex --dangerously-bypass-approvals-and-sandbox"
  214. pi: "pi"
  215. profiles:
  216. codex:
  217. fast:
  218. args: ["--model", "gpt-5-mini"]
  219. allowed_paths: [~/git, ~/projects]
  220. updates:
  221. check_enabled: false
  222. relay:
  223. enabled: true
  224. url: "wss://repowire.io"
  225. api_key: "rw_..."
  226. ```
  227. 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.
  228. Security defaults:
  229. - Local daemon binds to `127.0.0.1`.
  230. - Relay is opt-in and uses outbound WebSocket.
  231. - WebSocket and local HTTP auth are available through `daemon.auth_token`.
  232. - 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.
  233. - Spawn requires explicit command and path allowlists.
  234. - Experimental channel/ACP transport is opt-in.
  235. ## Developing From Source
  236. ```bash
  237. git clone https://github.com/prassanna-ravishankar/repowire
  238. cd repowire
  239. cd web && npm ci && npm run build && cd ..
  240. mkdir -p bin
  241. (cd daemon-go && go build -o ../bin/repowire .)
  242. ./bin/repowire setup --non-interactive
  243. ```
  244. Hooks and the MCP identity shim run the binary recorded by setup, not an
  245. arbitrary binary elsewhere in your checkout. Rebuild that binary after native
  246. changes, then restart the daemon service:
  247. ```bash
  248. (cd daemon-go && go build -o ../bin/repowire .)
  249. ./bin/repowire setup --non-interactive # rewrites hooks/MCP/service to this build
  250. ./bin/repowire service restart # enough when only daemon code changed
  251. ```
  252. If service management fails, use `repowire service status` first. Raw `launchctl` on macOS or `systemctl --user` on Linux are fallback troubleshooting tools.
  253. 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.
  254. ## References
  255. - [Start](https://docs.repowire.io/start/)
  256. - [Architecture](https://docs.repowire.io/operate/architecture/)
  257. - [MCP tools](https://docs.repowire.io/reference/mcp-tools/)
  258. - [CLI](https://docs.repowire.io/reference/cli/)
  259. - [Use](https://docs.repowire.io/use/)
  260. - [Features](https://docs.repowire.io/use/features/)
  261. - [Troubleshooting](https://docs.repowire.io/troubleshooting/)
  262. - [Compare](https://docs.repowire.io/start/compare/)
  263. ## Uninstall
  264. ```bash
  265. repowire uninstall
  266. rm -f ~/.local/bin/repowire
  267. rm -rf ~/.local/share/repowire
  268. ```
  269. `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.
  270. ## Contributing
  271. See [CONTRIBUTING.md](CONTRIBUTING.md). Before opening a PR, run the advisory repo-hygiene
  272. checklist:
  273. ```bash
  274. scripts/pre-pr-hygiene.sh
  275. ```
  276. It is an opt-in prompt for docs, README, and agent-instruction follow-ups, not a
  277. mandatory hook.
  278. ## License
  279. MIT
install.sh · Bundled script · 77 lines · 1 finding marked
  1. #!/bin/sh
  2. # 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
  3. set -eu
  4. repo="prassanna-ravishankar/repowire"
  5. os=$(uname -s)
  6. arch=$(uname -m)
  7. case "$os" in
  8. Darwin) os=darwin ;;
  9. Linux) os=linux ;;
  10. *) echo "Error: Repowire supports macOS and Linux (got $os)." >&2; exit 1 ;;
  11. esac
  12. case "$arch" in
  13. x86_64|amd64) arch=amd64 ;;
  14. arm64|aarch64) arch=arm64 ;;
  15. *) echo "Error: unsupported architecture $arch." >&2; exit 1 ;;
  16. esac
  17. if ! command -v curl >/dev/null 2>&1; then
  18. echo "Error: curl is required." >&2
  19. exit 1
  20. fi
  21. version=${REPOWIRE_VERSION:-}
  22. if [ -z "$version" ]; then
  23. version=$(curl -fsSL -H "Accept: application/vnd.github+json" \
  24. "https://api.github.com/repos/$repo/releases/latest" \
  25. | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
  26. | head -n 1)
  27. fi
  28. if [ -z "$version" ]; then
  29. echo "Error: could not determine the latest Repowire release." >&2
  30. exit 1
  31. fi
  32. case "$version" in v*) ;; *) version="v$version" ;; esac
  33. asset="repowire_${version#v}_${os}_${arch}.tar.gz"
  34. base="https://github.com/$repo/releases/download/$version"
  35. tmp=$(mktemp -d "${TMPDIR:-/tmp}/repowire.XXXXXX")
  36. trap 'rm -rf "$tmp"' EXIT HUP INT TERM
  37. echo "Installing Repowire $version for $os/$arch..."
  38. curl -fsSL "$base/$asset" -o "$tmp/$asset"
  39. curl -fsSL "$base/checksums.txt" -o "$tmp/checksums.txt"
  40. expected=$(awk -v name="$asset" '$2 == name {print $1}' "$tmp/checksums.txt")
  41. if [ -z "$expected" ]; then
  42. echo "Error: release checksum for $asset is missing." >&2
  43. exit 1
  44. fi
  45. if command -v sha256sum >/dev/null 2>&1; then
  46. actual=$(sha256sum "$tmp/$asset" | awk '{print $1}')
  47. else
  48. actual=$(shasum -a 256 "$tmp/$asset" | awk '{print $1}')
  49. fi
  50. if [ "$actual" != "$expected" ]; then
  51. echo "Error: checksum mismatch for $asset." >&2
  52. exit 1
  53. fi
  54. root=${REPOWIRE_INSTALL_DIR:-"$HOME/.local/share/repowire"}
  55. bin_dir=${REPOWIRE_BIN_DIR:-"$HOME/.local/bin"}
  56. target="$root/$version"
  57. mkdir -p "$target" "$bin_dir"
  58. tar -xzf "$tmp/$asset" -C "$target"
  59. chmod +x "$target/repowire"
  60. ln -sfn "$target/repowire" "$bin_dir/repowire"
  61. case ":$PATH:" in
  62. *":$bin_dir:"*) ;;
  63. *) echo "Note: add $bin_dir to PATH." ;;
  64. esac
  65. if ! command -v tmux >/dev/null 2>&1; then
  66. echo "Warning: tmux is not installed (needed for peer spawning)."
  67. fi
  68. echo "Installed Repowire $version to $target."
  69. "$target/repowire" setup "$@"
web/components/marketing/links.ts · Bundled script · 15 lines · 1 finding marked
  1. // Shared external link targets for the marketing site.
  2. //
  3. // The hosted dashboard is served by the relay at relay.repowire.io, not at
  4. // repowire.io/dashboard (that path is the local daemon's dashboard). Marketing
  5. // links point straight at the relay so visitors don't hit the local-style path
  6. // and rely on a client-side hostname redirect.
  7. export const RELAY_DASHBOARD_URL = "https://relay.repowire.io/dashboard";
  8. export const GITHUB_URL = "https://github.com/prassanna-ravishankar/repowire";
  9. export const DOCS_URL = "https://docs.repowire.io";
  10. export const RELEASES_URL = `${GITHUB_URL}/releases`;
  11. // Install commands, as the README's quickstart gives them.
  12. export const BREW_INSTALL = "brew install prassanna-ravishankar/repowire/repowire";
  13. 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 in

Free to use. If it’s helped, pass it on.