Voice + remote control for OpenCode: talk to the agent and let it talk back, and drive the same sessions from Telegram or any Nostr client — including a Telegram group where every session gets its own topic.
Voice
- Speech-to-text (STT) — press
<leader>v(or run/mic), speak, and the transcript becomes a prompt. Localfaster-whisperby default (offline, private, no API key), or any OpenAI-compatible/audio/transcriptionsendpoint; PipeWire, PulseAudio, ALSA,soxandffmpeg(AVFoundation on macOS, DirectShow on Windows) are auto-detected. - Text-to-speech (TTS) — the main agent's replies are spoken aloud with
neural voices (edge-tts), automatic pt / en / fr language detection and a
robotic
spd-sayfallback. Runs in the server plugin, so every client gets it; reasoning is opt-in. - Editable send + polish — by default
/mic sendopens an editable dialog so you can fix the transcript before it is sent, and the optionalpolishstep runs it through the model you are already using. - Voice in Telegram — incoming voice notes and audio files are transcribed
and attached to the prompt, so OpenCode receives the audio itself even when
transcription fails;
/talksends agent replies back as spoken audio messages. - Commands:
/mic(start|send|abort|off|status|help),/mic-setup(settings menu),/sound(on|off|pause|status|help),/talk—/talk helplists every command this plugin adds.
Remote control
- Telegram — in-process bot: project/session menus (
/menu,/projects,/project,/sessions,/new,/use), model + reasoning switching (/models,/model <number|provider/model> [effort]),/status,/abort,/nostr, plain-text prompts, in-place progress edits, agent photos and voice replies. Editing a submitted message stops the current run and re-prompts with the new text./telegram <bot-token> <group-id>registers the "Opencode Talk" group, where every session gets its own forum topic seeded with the session's project + model/reasoning; creating a topic there creates a new session, and session renames rename the topic./projectslists every OpenCode project (TUI/desktop picker) plusTELEGRAM_PROJECTS,/telegram <chat-id>links extra private chats, and/telegram stop|start|talk|shutcontrols the bot. - XMPP — same features as Telegram over XMPP:
/menu,/projects,/project,/sessions,/new,/use,/models,/model <number|provider/model> [effort],/status,/abort,/nostr, plain-text prompts, progress + voice replies./xmpp <jid> <password> [muc-room]connects the bot and registers the MUC room (one thread per session, seeded with project + model/reasoning);/xmpp <token>saves just the password when the JID comes fromXMPP_JID./xmpp <contact-jid>links extra direct chats,/xmpp room <muc-room>registers the room, and/xmpp stop|start|talk|shutcontrols the bot. Setup: docs/XMPP_SETUP.md. - Nostr — every session owns its own keypair (npub). Pair with
/nostr <your-npub>: the session DMs a welcome with the model + reasoning already selected. Encrypted NIP-04 DMs then drive the session with the same commands, scope projects, switch model/reasoning, abort, and receive agent images (Blossom)./nostr off|onhalts/resumes relay traffic. - Any other
/command— forwarded to OpenCode as-is, so custom commands and skills work remotely too. - Local prompts are mirrored — when you type a prompt in OpenCode
(TUI/desktop/web, including
/mictranscripts), it also appears in every Telegram/XMPP chat and Nostr DM bound to that session, so remote readers see both sides of the conversation. Remote-originated prompts and slash commands are never echoed. - Agent tool —
telegram_send_imagelets the agent push screenshots, charts and renders to your Telegram/Nostr chat. - Session API + remote plugin — REST + SSE for any client, typed RPC and compact progress events, single-flight loops and a shared poll lock that keeps exactly one Telegram poller even with several OpenCode servers. See Remote control below.
OpenCode's plugin API can't write into the prompt composer, so the transcript is delivered with
session.prompt(after an editable dialog). Toasts and the/mic-setupsettings menu are terminal-TUI features; the web/desktop clients only run the server commands.
/mic ──▶ recorder (temp WAV) ──▶ speech-to-text ──▶ (edit) ──▶ session.prompt
agent reply ──▶ text-to-speech (edge-tts) ──▶ speakers
src/recorder.tsspawns the first available capture tool and writes a mono 16 kHz WAV to a temp directory.src/transcribe.tsruns the configured backend (localfaster-whisperby default, or an OpenAI-compatible HTTP endpoint).src/tui.ts/index.tsdeliver the text to the active session (optionally edited in a dialog and optionally cleaned up by the current model first).src/speech.tsspeaks the main agent's replies withedge-tts(auto-detecting pt/en/fr) orspd-say, with a single, deduplicated queue.
Service/CLI plugins are two halves of one package: index.ts (server — the
/mic and /sound commands, plus TTS playback) and tui.ts (the terminal UI —
keybind, toasts, editable send and the settings menu).
- OpenCode v2 (
opencode --version→2.x). - A microphone and one capture tool:
pw-record(PipeWire),parecord(PulseAudio),arecord(ALSA),sox, orffmpeg. - For local STT:
faster-whisperin the bundled.venv(set up bynpm install) or any Whisper CLI. - For cloud STT: an API key for your provider.
This is already installed in ~/.config/opencode/opencode.jsonc, which is
what makes it appear in OpenCode's plugin/extension list:
Run npm install once in this directory: its postinstall hook creates the
bundled .venv and installs the Python engines (edge-tts for speech,
faster-whisper for transcription). Re-run it any time with npm run setup
(or OPENCODE_VOICE_SKIP_SETUP=1 npm install to skip the Python step, e.g. in
CI).
The plugin is self-configuring: at load it looks for
.venv/bin/python and scripts/whisper_transcribe.py next to itself, and uses
the bundled local engine when they exist. No options are required.
Why not
options? When a plugin is registered inopencode.json, OpenCode currently does not forward itsoptionsobject to the TUI half (context.optionsarrives empty). Configure it through environment variables instead, or use the CLI-onlycli.jsonform below if you wantoptions.
Set these before launching opencode:
| Variable | Purpose |
|---|---|
OPENCODE_VOICE_BACKEND |
local or api. Overrides auto-detection. |
OPENCODE_VOICE_LOCAL_COMMAND |
Shell command for the local backend. Supports {audio}. |
OPENCODE_VOICE_BASE_URL |
OpenAI-compatible base URL (cloud backend). |
OPENCODE_VOICE_MODEL |
Cloud transcription model. |
OPENCODE_VOICE_API_KEY |
Cloud bearer token. Also read from OPENAI_API_KEY/GROQ_API_KEY. |
OPENCODE_VOICE_LANGUAGE |
ISO-639-1 hint, e.g. en. |
OPENCODE_VOICE_WHISPER_MODEL |
faster-whisper model: base (default), tiny.en, small, … |
OPENCODE_VOICE_WHISPER_LANGUAGE |
Language for the local wrapper (default: auto-detect). |
OPENCODE_VOICE_WHISPER_COMPUTE |
int8 (default), int8_float16, float16, float32. |
CLI-only install (honours options, but not listed)
Plugins declared in cli.json keep their options and stay active even against
a remote server, but they do not show in the plugin/extension list:
{
"$schema": "https://opencode.ai/v2/cli.json",
"plugins": [
{
"package": "/home/hdlrocha/opencode-voice",
"options": {
"backend": "local",
"localCommand": "/home/hdlrocha/opencode-voice/.venv/bin/python /home/hdlrocha/opencode-voice/scripts/whisper_transcribe.py {audio}",
"keybind": "<leader>v",
"slash": "voice"
}
}
]
}Alternative: discovery via a plugins directory
OpenCode also discovers plugins under the global config directory and project
.opencode directories, so you can symlink this project instead of editing
opencode.jsonc:
mkdir -p ~/.config/opencode/plugins
ln -sfn /home/hdlrocha/opencode-voice ~/.config/opencode/plugins/micThe tui.ts and index.ts files at the project root are the entry points used
by that layout.
Restart the terminal app (or run opencode service restart) so the plugin is
picked up.
Override the command binding in cli.json:
{
"keybinds": { "voice.input.toggle": "ctrl+shift+v" }
}- Open a session.
- Start recording — press
<leader>v(by defaultCtrl+Xthenv), or run/mic(/mic startalso works). - A "Recording…" toast appears. Speak.
- Stop & transcribe — press the key again, run
/mic(it toggles), or/mic send. By default this opens an editable dialog with the transcript so you can fix it before sending (press Enter to send, Esc to discard). SetOPENCODE_VOICE_SUBMIT=sendto send directly instead. - To cancel (discard, send nothing), run
/mic abort(cancel,abort,pararalso work). - Run
/mic help(or/sound help) any time to see the command reference,/mic status(or/sound status) for current state.
Recording also stops automatically after maxDuration seconds (default 120).
Run /mic-setup (or pick Voice: configuração from Ctrl+P) to:
- switch between local transcription (no key needed) and the cloud API;
- set the API key,
baseURLand model — stored at~/.config/opencode/voice.json(mode0600, outside this repository, so it is never committed); - choose the Portuguese, English and French TTS voices and toggle language auto-detection;
- enable/disable speech, and choose whether the agent's reasoning ("thinking") is spoken too;
- review the current settings (the key is shown masked).
Changes apply immediately — the plugin re-reads voice.json on every use.
The plugin also reads the main agent's messages aloud:
- Only the main agent — messages from subagent/child sessions are never spoken.
- Only assistant prose — tool calls and shell/command output are not spoken. Code blocks, inline code, URLs and Markdown markup are stripped first so it reads like speech.
- Reasoning is opt-in — the agent's grey "thinking" text is skipped unless you enable it with
OPENCODE_VOICE_TTS_REASONING=1(or the settings menu). Off by default. - Runs in the server plugin, so it works in every client (TUI, desktop, web).
- Utterances are queued and serialized machine-wide, so agent messages and reasoning parts play one after another instead of talking over each other.
The default engine is edge-tts — Microsoft's neural voices, which sound
natural and include European Portuguese (pt-PT-RaquelNeural) and English
(en-US-AriaNeural). It is wired in through the bundled wrapper
scripts/edge_tts_play.py; if synthesis or playback ever fails it falls back to
spd-say. The wrapper also survives Microsoft's 2026 Read Aloud migration:
when the legacy speech.platform.bing.com endpoint answers 403 (as it does in
several regions), it retries on the new api.msedgeservices.com host, so the
natural voice keeps working.
Language auto-detection: each message is classified as Portuguese, English or
French and the matching voice is used, so replies are read with the right voice.
Inconclusive text (numbers, very short replies) is read with the English
voice. Set OPENCODE_VOICE_TTS_AUTO=0 to disable detection (then everything
uses OPENCODE_VOICE_TTS_VOICE).
Because edge-tts uses an online service, it needs internet at speak time. For a
completely offline voice, use Piper (below), or force the robotic fallback with
OPENCODE_VOICE_TTS_ENGINE=spd-say.
Configure with environment variables (set them before launching opencode, then
opencode service restart):
| Variable | Default | Purpose |
|---|---|---|
OPENCODE_VOICE_TTS |
1 |
Set to 0 to disable speech. |
OPENCODE_VOICE_TTS_ENGINE |
auto (command) |
command (bundled edge-tts), spd-say, or your own command. |
OPENCODE_VOICE_TTS_AUTO |
1 |
Auto-detect PT/EN/FR and pick the matching voice (EN when unclear). |
OPENCODE_VOICE_TTS_REASONING |
0 |
Set to 1 to also speak the agent's reasoning ("thinking") text. |
OPENCODE_VOICE_TTS_VOICE |
pt |
Portuguese voice: pt, pt-br, or a full edge voice name. |
OPENCODE_VOICE_TTS_VOICE_EN |
en-US-AriaNeural |
Voice used for English messages. |
OPENCODE_VOICE_TTS_VOICE_FR |
fr-FR-DeniseNeural |
Voice used for French messages. |
OPENCODE_VOICE_TTS_RATE |
0 |
-100..100 (positive is faster). |
OPENCODE_VOICE_TTS_MAX |
1500 |
Max characters spoken per message (0 = no limit). |
OPENCODE_VOICE_TTS_COMMAND |
bundled edge wrapper | Command for engine=command; the text is written to its stdin. |
OPENCODE_VOICE_EDGE_VOICE |
– | Explicit edge voice, overrides the language-based choice. |
Voice mapping: pt → pt-PT-RaquelNeural, pt-br → pt-BR-FranciscaNeural,
en → en-US-AriaNeural, en-gb → en-GB-SoniaNeural,
fr → fr-FR-DeniseNeural, es → es-ES-ElviraNeural, and so on. Examples:
OPENCODE_VOICE_TTS_VOICE=pt-PT-DuarteNeural # male European Portuguese
OPENCODE_VOICE_TTS_VOICE_EN=en-GB-SoniaNeural # British English/sound— toggle speech on/off. When turning it on it says “Voz ligada.”/sound on(start,ligar) — enable speech./sound off(stop,desligar) — disable speech and stop speaking immediately (cuts the current utterance and clears the queue)./sound pause(silence,calar,parar) — silence now, but keep speech on./sound status— show switch, engine, voices and limits./sound help(ajuda) — show the command usage.
Starting a recording (/mic, /mic start) automatically silences the current
utterance so the microphone doesn't pick it up.
Works from any client, and persists to ~/.config/opencode/voice.json.
Piper is a small neural TTS that runs
offline — less natural than edge-tts, but far better than espeak-ng. Install it
and a Portuguese voice, then point OPENCODE_VOICE_TTS_COMMAND at it (Piper
reads the text on stdin and writes WAV to stdout):
.venv/bin/python -m pip install piper-tts
# download a voice, e.g. pt_PT-tugão-medium.onnx (+ .json) into ~/mics
export OPENCODE_VOICE_TTS_COMMAND="$PWD/.venv/bin/piper -m $HOME/mics/pt_PT-tugao-medium.onnx -f - | paplay"
opencode service restartAny command that consumes text on stdin and plays audio works (e.g. espeak,
piper, a cloud TTS CLI).
These are read from the plugin options object when the plugin is loaded via
cli.json. With the opencode.json install they are ignored — use the
environment variables above instead.
| Option | Default | Description |
|---|---|---|
backend |
"local" when bundled, else env |
"api" for an OpenAI-compatible endpoint, "local" for a CLI. |
baseURL |
https://api.openai.com/v1 |
API base URL. |
apiKey |
from env | Bearer token. Supports {env:NAME}. |
apiKeyEnv |
inferred from baseURL |
Name of the env var that holds the key. |
model |
gpt-4o-mini-transcribe |
Transcription model (whisper-1, whisper-large-v3-turbo, …). |
language |
auto | ISO-639-1 hint, e.g. "en". |
prompt |
– | Vocabulary/spelling hint passed to the recognizer. |
localCommand |
bundled whisper wrapper | Shell command for the local backend. Tokens: {audio}, {outdir}, {out}. |
localShell |
sh / cmd |
Shell used to run localCommand. |
keybind |
"<leader>v" |
Binding, or false to disable the automatic binding. |
slash |
"mic" |
Slash command name, or "" to disable it. Registered with arguments: true so typing /mic + Enter runs it. |
aliases |
["stt"] |
Slash aliases. |
confirm |
false |
Show a dialog to review the text before sending. |
submitMode |
"edit" |
"edit" opens an editable dialog before sending; "send" sends directly. |
delivery |
"steer" |
"steer" to send now, "queue" to append behind running work. |
prefix |
"" |
Text prepended to the transcript. |
suffix |
"" |
Text appended to the transcript. |
polish |
false |
Clean the transcript with the current model before sending. |
polishPrompt |
built-in instruction | Prompt used by polish; the raw transcript is appended. |
recorder |
"auto" |
pw-record, parecord, arecord, ffmpeg, or sox. |
sampleRate |
16000 |
Capture sample rate. |
maxDuration |
120 |
Auto-stop after this many seconds (0 disables). |
minDuration |
0.35 |
Reject recordings shorter than this many seconds. |
keepAudio |
false |
Keep the WAV file for debugging. |
timeoutMs |
60000 |
HTTP timeout for the transcription request. |
The bundled wrapper is used automatically. npm install (postinstall) or
npm run setup creates the environment with both engines:
npm install # dev deps + .venv (edge-tts, faster-whisper)
npm run setup # run just the Python setup again
OPENCODE_VOICE_SKIP_SETUP=1 npm install # skip the Python step (CI)The model is downloaded on first use and cached by Hugging Face. Tune it with environment variables:
export OPENCODE_VOICE_WHISPER_MODEL=base.en # tiny.en is faster, small is more accurate
export OPENCODE_VOICE_WHISPER_LANGUAGE=en # skip auto-detectPoint localCommand/OPENCODE_VOICE_LOCAL_COMMAND at any other Whisper CLI if
you prefer. For openai-whisper:
whisper {audio} --model small --language en --output_format txt --output_dir {outdir}
For whisper.cpp:
whisper-cli -m /path/to/ggml-base.en.bin -f {audio} -otxt -of {out}
export OPENCODE_VOICE_BACKEND=api
export OPENCODE_VOICE_BASE_URL=https://api.groq.com/openai/v1
export OPENCODE_VOICE_MODEL=whisper-large-v3-turbo
export OPENAI_API_KEY= # not used
export GROQ_API_KEY=gsk_...export OPENCODE_VOICE_BACKEND=api
export OPENCODE_VOICE_BASE_URL=https://api.groq.com/openai/v1
export OPENCODE_VOICE_MODEL=whisper-large-v3-turbo
export GROQ_API_KEY=gsk_...With the cli.json install:
{
"package": "/home/hdlrocha/opencode-voice",
"options": { "confirm": true, "polish": true, "language": "en" }
}- The plugin is not in the plugins list — it must be registered in
opencode.json(c)(notcli.json) and the server must be restarted. Verify withopencode plugin listandopencode api get /api/plugin. - "no microphone recorder available" — install one of
pipewire(pw-record),pulseaudio-utils(parecord),alsa-utils(arecord),sox, orffmpeg. On macOS/Windows you needffmpeg. - "recording produced no audio" — the recorder started but captured
nothing. Check your input device and, on macOS, that
ffmpeg -f avfoundation -i :0lists a real audio device index. - "transcription failed" / empty text — try a larger model
(
OPENCODE_VOICE_WHISPER_MODEL=small) or setOPENCODE_VOICE_WHISPER_LANGUAGE=en. - "no API key" — the cloud backend was selected but no key is available;
set
OPENAI_API_KEY/GROQ_API_KEY, or unsetOPENCODE_VOICE_BACKENDto use the bundled local engine. - Nothing happens on
<leader>v— the leader key may be rebound. Checkkeybinds.leader, or bind the command directly withkeybinds["voice.input.toggle"].
npm install # dev deps + the bundled Python engines (.venv)
npm run typecheck # tsc --noEmit (voice + remote)
npm test # typecheck + voice smoke test + remote vitest suites
npm run build # compile the remote runtime (Session API + bots) to dist/OpenCode resolves @opencode/plugin/tui at runtime, so the plugin runs without
a build step. The import is only needed locally for TypeScript.
The same sessions, from your phone or any Nostr client — through an independent Session API (REST + SSE) and a small OpenCode plugin. Voice and remote are independent halves: use either or both.
Telegram → Telegram Adapter →┐
├→ Session API → Remote Plugin → OpenCode Session
Nostr → Nostr Adapter →┘
- Telegram (
src/remote/telegram/): grammY standalone bot + in-process plugin bot (pluginBot.ts, raw Bot API polling)./sessions,/new,/use <n|id>,/status,/abort,/nostr [npub]; plain text prompts the selected session; progress edits one🤖 …message; agent screenshots arrive as photos. From OpenCode,/telegram <bot-token> <group-id>registers an "Opencode Talk" group and/telegramgives every session its own forum topic (project + model/reasoning seeded from the session)./telegram <chat-id>still links an extra private chat. Setup: docs/TELEGRAM_SETUP.md. - Nostr (
src/remote/nostr/): encrypted DMs, two modes. Plugin-native (recommended): the remote plugin itself connects to relays — each session owns a keypair, DM its npub directly, pair with OpenCode/nostr <your-npub>. Standalone: encrypted-DM client of the Session API, paired via Telegram/nostr <your-npub>. Setup: docs/NOSTR_SETUP.md. - Session API (
src/remote/session-api/+src/remote/opencode/): Express server over@opencode/client— session CRUD,POST …/message,…/abort, media store for agent images, SSE fan-out. Reference: docs/API.md. - Remote plugin (
remote-plugin/, idtelegram-bridge): typed RPC (sendMessage/abort/status), compact progress events, atelegram_send_imageagent tool ("run the app 2 minutes and send me the screenshot"), and the in-process Nostr bridge (/nostr). Install: docs/PLUGIN_INSTALL.md. - Prompt mirroring: a prompt typed locally in OpenCode (TUI/desktop/web,
/mictranscripts included) is posted as👤 …into every Telegram chat, XMPP chat and Nostr DM bound to that session. Prompts that came from a remote bridge are not echoed back, and slash commands stay local.
Quick start (plugin-native Telegram + Nostr — no API/bot processes):
export TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
export TELEGRAM_ALLOWED_USERS=123456789
export NOSTR_RELAYS=wss://nos.lol,wss://relay.snort.social
export NOSTR_ALLOWED_NPUBS=npub1you...
opencode service restart
# Telegram: message the bot, /sessions, /use 1 — or link from OpenCode: /telegram <chat-id>
# Bot + group: /telegram <bot-token> <group-id>, or /telegram group <group-id> after /telegram <bot-token>
# Voice to Telegram: /telegram talk (off with /telegram shut); halt bot: /telegram stop
# Every plugin command: /talk help
# Nostr: inside OpenCode: /nostr, then /nostr <your-npub>, then DM the session npubUse a single Telegram group as a session hub instead of private chats. One-time setup:
- Open a chat with @BotFather and send
/newbot. - Pick a display name (e.g.
OpenCode Talk) and a username ending inbot(e.g.opencode_talk_bot). - Copy the token BotFather replies with (
123456:ABC-DEF...) — treat it like a password. The plugin saves it toTELEGRAM_TOKEN_FILE(mode 0600). - Optional but recommended:
/setjoingroups→ Enable (default) so the bot can be added to the group./setprivacy→ select the bot → Disable. An admin bot receives all group messages anyway (see step 3), but disabling privacy keeps plain-text prompts working if the bot is ever demoted.
- Telegram → New Group → name it Opencode Talk → add the bot as a member (search its @username).
- Open the group → Edit → enable Topics (forum mode). Without Topics the bot cannot create the per-session topics.
- Find the group id (negative, e.g.
-1001234567890):- add @userinfobot to the group — it posts the group id (remove it afterwards), or
- send a message in the group and open
https://api.telegram.org/bot<TOKEN>/getUpdatesin a browser — look for"chat":{"id":-100…}. This needs the bot to be an admin or to have privacy disabled (steps 1.4/3).
- Group → Edit → Administrators → Add Admin → select the bot.
- Enable:
- Manage Topics — required: creates the per-session forum topics.
- Send Messages — required (on by default).
- Delete Messages — optional: lets it tidy its own progress messages.
- Save. As an admin the bot receives every group message, regardless of privacy mode.
- In OpenCode run
/telegram <bot-token> <group-id>: the token is verified, saved locked-down (TELEGRAM_TOKEN_FILE, mode 0600), the bot connects, and the group is registered. You can also do it in two steps — connect the bot with/telegram <bot-token>, then the group with/telegram group <group-id>. - From any session run
/telegram(or any time later): the bot creates or reuses a topic named after the session, binds it, and posts the first message showing the session's project and model + reasoning already selected. - Write in a topic to prompt that session — progress edits and results stay
in the topic.
/models,/model,/status,/abort,/nostrwork there too;/telegram statusshows state without touching the group. - Creating a topic yourself works in reverse: the bot creates a new session named after the topic, binds it, and asks for model + reasoning. Telegram only delivers topic-creation notices to administrators, so keep the bot an admin (step 3).
- Renaming the session (e.g. in the TUI) renames its bound topic to match. A topic renamed by hand stays as typed until the session is renamed again.
Prerequisites: group mode requires the plugin-native bot (it creates
topics through the same in-process polling loop); TELEGRAM_ALLOWED_USERS
must contain your user id. The standalone dev:bot process ignores topic
mappings.
Telegram allows only one getUpdates consumer per bot token. If several
OpenCode servers run (e.g. the desktop app's server plus the background
opencode serve --service), the first to start polls and the others run in
secondary mode — no polling, but topic linking and sends still work from
those processes — instead of fighting with 409 Conflict.
TELEGRAM_LOCK_FILE overrides the shared lock path when the plugin is
installed in more than one place. Mappings, token/account files, bot state
and media resolve against the install directory (not each server's working
directory), so every server shares them — absolute *_FILE paths in .env
still win when set. Stopping extra servers is still recommended: with several
servers only one polls, and linked topics reply from whichever holds the
poller.
Quick start (standalone adapters via the Session API):
cp .env.example .env # SESSION_API_TOKEN, TELEGRAM_BOT_TOKEN, ...
npm run dev:api # Session API on 127.0.0.1:3456
npm run dev:bot # Telegram bot
npm run dev:nostr # Nostr adapter (needs NOSTR_RELAYS)Remote config lives in .env (see .env.example); voice config stays in
voice.json. Secrets for both are git-ignored.
{ "$schema": "https://opencode.ai/config.json", "plugins": ["/home/hdlrocha/opencode-voice"] }