share this session with the team

Show the work.

OpenShare turns any opencode session into a live, readable web page. One command in the terminal, one URL for everyone else.

/share https://your-worker.dev/s/a1b2…

3 prompts21 tool calls1 snake game0 accounts required

Get the plugin Read the docs

A shared agent session in the classic view: the turns sidebar on the left, a prompt bubble on the right, and below it the response with reasoning, shell, write, read and edit tool rows carrying real diff counts. — A real session, curated for this page: build a Snake game, fix two bugs, add polish. What you see is what the agent did.

how does it work?

One command. Then it's a URL.

Type /share in the opencode TUI. The session streams to your worker over a live socket: every tool call, every thought, every file edit, in order. Readers get a page that updates while the agent works. No account, no install, nothing to explain.

readers need no account
live while the agent works
expires on your timer

what can it do?

The transcript is the artifact.

The same transcript, twelve skins: the dense classic timeline, a conversation view, reader mode, a field atlas, a screenplay, more. Virtualized rendering keeps a 10,000-message session scrolling at full speed, and every view shares the same search, deep links and keyboard navigation.

Classic view: the full session timeline with the prompt rail on the left.

A snapshot is a single HTML file with everything inside: the transcript, the viewer, highlighting, the fonts. Put it on a USB stick, mail it to a reviewer, open it from disk with no server and no internet. The header even says snapshot, so nobody mistakes a frozen copy for the live page.

# attach the agent's session to a failing CI run
- name: attach agent session
  run: node tools/osh-snapshot.mjs "$SHARE_URL" --token "$OSK" -o session.html

Reviewers of the red build open one file and watch what the agent actually tried, in order, with the file edits highlighted.

Full-text search across prompts, responses, thinking and tool output. Marks persist while you scroll, collapsed rows expand as hits come into view, and every hit deep-links to the exact row. Because the transcript is the artifact, not a picture of it.

Secrets are redacted before anything leaves your machine: API keys, tokens, PEM blocks, .env pairs, connection strings. File paths relativize to the project. Gate any share behind a login and password, set an expiry in hours, and hand CI a scoped token that can only touch its own shares. Server operators are a chain you choose, not a platform you trust.

curl -H "Authorization: Bearer [redacted:api-key]" https://api.example.com/v1/[redacted:secret]

Paste the link into Discord, Slack, or anything that reads OpenGraph: a real card with the session's title, status, turns, tools and duration, rendered by your own worker. Private shares show a lock and nothing else, so crawlers learn nothing.

look what the agent did overnight your-worker.workers.dev/s/7f3a… Link preview card: the session title, a turns, tools and duration stat line, and a Completed badge on a dark card with an amber aurora.

Link preview card: the session title, a turns, tools and duration stat line, and a Completed badge on a dark card with an amber aurora.

what does it look like?

Every state, on the record.

All of this is the same transcript, the same session. Collapse the sidebar to a 12px pill. Split a diff into panes with real line numbers. Search everything and watch the marks hold while you scroll.

An edit tool expanded into a split diff: red-tinted removed lines and green-tinted added lines with real line numbers and syntax highlighting, the unified/split toggle in the card header. — **edit, split**: real line numbers from the file, red/green by hunk, unified on narrow screens

The search palette open over the transcript: the query 'snake', ten results grouped by scope chips, yellow marks painted on every hit, and the highlighted file body behind it. — **search**: prompts, responses, thinking, tools; marks persist while you scroll

The same session with the sidebar collapsed: the transcript takes the full width and a slim pill on the left edge marks the current turn. — **collapsed**: the sidebar folds into a pill that takes 12px and never leaves

is it fresh?

Alive while it works.

Shares stream over a live socket. A reader watching mid-run sees the turn you're in: tools opening, reasoning unfolding, the revision counter ticking. Finished, interrupted, live: the page tells the truth about the run.

can i touch it?

Don't take our word for it. Click around.

This is the real viewer with the real session from above, frozen into a single HTML file by the snapshot button. Expand the tools, run a search, switch views in the header, resize the output panes. It is the whole product, offline, in this page.

open it fullscreen ↗ 7.5 MB, works from a USB stick, no server involved

what does a real session look like?

The full tour: every tool, real work.

A second curated session, driven to exercise the whole surface: a test run that fails red then passes green, a subagent with its own page, an image the agent drew and inspected, grep and glob results, a todo list, web fetches, display math and a rust snippet in the prose. Nothing staged: same viewer, same snapshot button, real session.

open the tour fullscreen ↗ two sessions, 12 prompts, every tool the plugin shares

who holds the data?

You do. It's your worker.

OpenShare is a Cloudflare Worker you deploy in three commands, or a single Bun binary you run anywhere. Both speak the same protocol. The free tier is enough for a team; there is no OpenShare cloud, no telemetry home, no vendor.

git clone https://github.com/Mirrowel/openshare && cd openshare
cd share-viewer && npm install && npm run build && cd ..
cd share-worker && npx wrangler deploy      # or: bun share-server/server.ts
curl -s https://your-worker.workers.dev/health

ship it

The session is the artifact.

Get the plugin