@sidevoice/uplink 0.4.3 → 0.5.0

package/install.mjs

@@ -1,256 +0,0 @@
-#!/usr/bin/env node
-/** `sidevoice install` — put this version of Sidevoice in front of the harnesses on this machine.
- *
- *  It registers the MCP server (re-pinned to this version when an older one was registered), installs
- *  the skill, says what it changed, and is safe to run twice: run it again after an upgrade and the
- *  harness points at the new version. It pairs with nothing. Pairing is a person's act — the room shows
- *  a one-time code to whoever is in it, and a conversation asks for it the first time it joins — so
- *  the installer only reports whether this machine is paired, and with which room.
- *
- *  What it does not do is decide for the person: it never edits a machine-wide Codex configuration it
- *  does not own, and it never relaxes Claude Code's inbound safeguard — those it prints, with the reason. */
-import { execFileSync } from 'node:child_process';
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { pairedRoom } from './pair.mjs';
-import { remove as removeSkill, skillsDir, status as skillStatus } from './skill.mjs';
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const VERSION = JSON.parse(readFileSync(path.join(here, 'package.json'), 'utf8')).version;
-/** The files that make up this package, copied as they are. */
-const PACKAGE_FILES = JSON.parse(readFileSync(path.join(here, 'package.json'), 'utf8')).files.concat('package.json');
-
-function fromSource(env) {
-  if (env.SIDEVOICE_INSTALL_FROM_SOURCE === '0') return false;
-  return env.SIDEVOICE_INSTALL_FROM_SOURCE === '1' || existsSync(path.join(here, '..', '..', '.git'));
-}
-
-/** Where installed copies live: one directory per version, under the XDG data home. */
-export function copiesDir(env = process.env) {
-  return path.join(env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), 'sidevoice');
-}
-
-/** What a harness should run to start the server. From a checkout it names that checkout, so a machine that
- *  installed from source keeps working when the published version moves. Otherwise it names a copy of this
- *  package that install placed on disk — never `npx`: a session start is not the moment to resolve a package
- *  (a cold cache, a bin whose name differs from the package's, a 30 s startup budget; one session found no
- *  `sidevoice` binary at all, 2026-09-21). */
-export function serverCommand(env = process.env) {
-  const cli = fromSource(env) ? path.join(here, 'cli.mjs') : path.join(copiesDir(env), VERSION, 'cli.mjs');
-  return { command: 'node', args: [cli, 'mcp'] };
-}
-
-/** Put this version's files where serverCommand points, and drop the other versions: an installed copy is
- *  disposable and there is one current one. From a checkout nothing is copied. */
-export function materialize(env = process.env) {
-  if (fromSource(env)) return { action: 'checkout', target: here };
-  const root = copiesDir(env), target = path.join(root, VERSION);
-  mkdirSync(target, { recursive: true });
-  for (const file of PACKAGE_FILES) {
-    const source = path.join(here, file);
-    if (existsSync(source)) cpSync(source, path.join(target, file), { recursive: true });
-  }
-  const removed = [];
-  for (const name of readdirSync(root)) {
-    if (name !== VERSION) { rmSync(path.join(root, name), { recursive: true, force: true }); removed.push(name); }
-  }
-  return { action: 'copied', target, removed };
-}
-
-/** The connector that holds this machine's socket, if any, and which version it is: a façade uses whatever
- *  connector is running, so one left over from before an upgrade serves every new session with old code. */
-export function runningConnector(env = process.env) {
-  const dataDir = env.SIDEVOICE_DATA_DIR || path.join(os.homedir(), '.sidevoice');
-  const socketPath = env.SIDEVOICE_CONNECTOR_SOCKET || path.join(dataDir, 'connector.sock');
-  let pid = null;
-  try { pid = Number(readFileSync(socketPath + '.lock', 'utf8')) || null; } catch { return null; }
-  return new Promise(resolve => {
-    const socket = net.createConnection(socketPath);
-    const done = value => { clearTimeout(timer); socket.destroy(); resolve(value); };
-    const timer = setTimeout(() => done(null), 1500);
-    let buffer = '';
-    socket.on('error', () => done(null));
-    socket.on('connect', () => socket.write(JSON.stringify({ id: 1, method: 'status', params: {} }) + '\n'));
-    socket.on('data', chunk => {
-      buffer += chunk; const index = buffer.indexOf('\n'); if (index < 0) return;
-      try { const reply = JSON.parse(buffer.slice(0, index)); done({ pid, version: reply.result?.version || null, bindings: reply.result?.bindings?.length ?? null }); }
-      catch { done({ pid, version: null, bindings: null }); }
-    });
-  });
-}
-
-export function flag(argv, name) {
-  const index = argv.indexOf(name);
-  return index >= 0 ? argv[index + 1] : undefined;
-}
-
-/** Which harnesses this machine has, by what they leave behind. */
-export function harnessesPresent(env = process.env) {
-  const found = [];
-  if (existsSync(env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'))) found.push('claude');
-  if (existsSync(env.CODEX_HOME || path.join(os.homedir(), '.codex'))) found.push('codex');
-  return found;
-}
-
-function claude(args, env) {
-  return execFileSync(env.SIDEVOICE_CLAUDE_BIN || 'claude', args, { encoding: 'utf8', timeout: 30_000, env, stdio: ['ignore', 'pipe', 'pipe'] });
-}
-
-/** What Claude Code currently runs for `sidevoice`, read from its own `mcp get`: null when nothing is
- *  registered or there is no `claude` to ask. The scope matters — only a user-scope entry is ours to move. */
-export function claudeRegistration(env = process.env) {
-  let output;
-  try { output = claude(['mcp', 'get', 'sidevoice'], env); } catch { return null; }
-  const field = name => (output.match(new RegExp(`^\\s*${name}:\\s*(.*)$`, 'm')) || [])[1]?.trim() ?? '';
-  const command = field('Command'), args = field('Args');
-  if (!command) return null;
-  return { scope: /user/i.test(field('Scope')) ? 'user' : 'other', line: [command, args].filter(Boolean).join(' ') };
-}
-
-function registerWithClaude(done, env) {
-  const { command, args } = serverCommand(env);
-  const wanted = [command, ...args].join(' ');
-  const manual = `claude mcp add --scope user sidevoice -- ${wanted}`;
-  const current = claudeRegistration(env);
-  if (current?.line === wanted) { done.push('Claude Code already runs this version of the MCP server.'); return; }
-  if (current && current.scope !== 'user') {
-    done.push(`Claude Code has a sidevoice MCP server registered outside user scope (${current.line}); not touched. To move it:\n    ${manual}`);
-    return;
-  }
-  try {
-    if (current) claude(['mcp', 'remove', '--scope', 'user', 'sidevoice'], env);
-    claude(['mcp', 'add', '--scope', 'user', 'sidevoice', '--', command, ...args], env);
-    done.push(current ? `Re-pointed Claude Code's MCP server to this version (was: ${current.line}).`
-                      : 'Registered the MCP server with Claude Code (user scope).');
-  } catch (error) {
-    done.push(`Could not register with Claude Code automatically (${(error.message || '').split('\n')[0]}). Run:\n    ${manual}`);
-  }
-}
-
-/** Codex keeps one machine-wide file that may hold anything its user put there: we never rewrite it. */
-export function codexInstructions(env = process.env) {
-  const { command, args } = serverCommand(env);
-  return [
-    `Add to ${env.CODEX_HOME || path.join(os.homedir(), '.codex')}/config.toml — it is machine-wide and`,
-    'this package does not rewrite it:',
-    '',
-    '  [mcp_servers.sidevoice]',
-    `  command = "${command}"`,
-    `  args = [${args.map(a => `"${a}"`).join(', ')}]`,
-    '',
-    'Then restart Codex. That is all: read receipts and working state come from what Codex records about the thread.',
-  ].join('\n');
-}
-
-/** Claude Code holds messages from other local processes when a session bypasses permission prompts. */
-export function inboundWarning(env = process.env) {
-  const settings = path.join(env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'), 'settings.json');
-  let parsed = {};
-  try { parsed = JSON.parse(readFileSync(settings, 'utf8')); } catch { return null; }
-  if (parsed.crossSessionInbound) return null;
-  if (parsed.permissions?.defaultMode !== 'bypassPermissions') return null;
-  return [
-    'This machine runs Claude Code sessions in bypassPermissions, and those hold what the room sends',
-    'instead of delivering it — voice looks sent and never arrives. Either start a session with',
-    `  --settings '{"crossSessionInbound":"accept"}'`,
-    `or add "crossSessionInbound": "accept" to ${settings}. That second one lets any local process post`,
-    'into every Claude session on this machine, which is the safeguard it removes: your call, not ours.',
-  ].join('\n');
-}
-
-export async function install(argv = process.argv.slice(2), env = process.env) {
-  const stray = argv.find(item => !item.startsWith('-') && argv[argv.indexOf(item) - 1] !== '--harness');
-  if (stray) throw new Error(`usage: sidevoice install [--harness claude|codex]\n` +
-    `Pairing is not part of installing: a conversation asks for the room's code the first time it joins, ` +
-    `or run  sidevoice pair <room-url> <code>  with the code the room shows under "Emparejar conector".`);
-  const wanted = flag(argv, '--harness');
-  const harnesses = wanted ? [wanted] : harnessesPresent(env);
-  const done = [], next = [];
-
-  done.push(`Sidevoice ${VERSION}.`);
-  const copy = materialize(env);
-  if (copy.action === 'copied') done.push(`Copied this version to ${copy.target}${copy.removed.length ? ` (removed: ${copy.removed.join(', ')})` : ''}.`);
-  if (harnesses.includes('claude')) {
-    registerWithClaude(done, env);
-    // The join shortcut is a prompt the server offers; a skill copy from an earlier version is taken away.
-    if (skillStatus(skillsDir([], env)).state === 'installed') done.push(`Removed the voice-room skill copy at ${removeSkill(skillsDir([], env)).target}: the server offers it as the prompt /mcp__sidevoice__voice-room.`);
-  }
-
-  const paired = pairedRoom(env);
-  done.push(paired ? `This machine is paired with ${paired.origin} (connector ${paired.connector_id}).`
-                   : 'This machine is not paired with any room yet.');
-  const running = await runningConnector(env);
-  if (running && running.version !== VERSION) {
-    next.push(`A connector from ${running.version ? 'version ' + running.version : 'an older version'} is still running (pid ${running.pid}) and every conversation on this machine uses it. ` +
-              `It exits by itself 15 s after the last conversation leaves it; to switch now: kill ${running.pid}, then join again from each conversation.`);
-  }
-
-  if (harnesses.includes('claude')) {
-    next.push('In a conversation, ask to join the voice room (or run /mcp__sidevoice__voice-room).' +
-              (paired ? '' : ' The first time, the conversation asks you for the room\'s address and the one-time code the room shows under "Emparejar conector".'));
-    next.push('Sessions already open need a restart before they see the server.');
-    const warning = inboundWarning(env);
-    if (warning) next.push(warning);
-  }
-  if (harnesses.includes('codex')) next.push(codexInstructions(env));
-  if (!harnesses.length) next.push('No harness found on this machine. Pass --harness claude or --harness codex.');
-  return { done, next };
-}
-
-/** `sidevoice uninstall`: the reverse of install, for this machine. Unregisters the MCP server from Claude
- *  Code, stops the connector, removes the installed copies, the skill copy an older version left, and the
- *  pairing credential. The room keeps this machine's pairing until it is revoked from the room's page —
- *  say so. Codex's machine-wide file is, as always, printed and not touched. */
-export async function uninstall(argv = process.argv.slice(2), env = process.env) {
-  const wanted = flag(argv, '--harness');
-  const harnesses = wanted ? [wanted] : harnessesPresent(env);
-  const done = [], next = [];
-  if (harnesses.includes('claude')) {
-    const current = claudeRegistration(env);
-    if (current?.scope === 'user') {
-      try { claude(['mcp', 'remove', '--scope', 'user', 'sidevoice'], env); done.push('Unregistered the MCP server from Claude Code.'); }
-      catch (error) { done.push(`Could not unregister from Claude Code (${(error.message || '').split('\n')[0]}). Run:\n    claude mcp remove --scope user sidevoice`); }
-    } else if (current) {
-      next.push(`Claude Code has a sidevoice MCP server registered outside user scope (${current.line}); remove it where it was added.`);
-    } else done.push('Claude Code had no sidevoice MCP server registered.');
-    if (skillStatus(skillsDir([], env)).state === 'installed') done.push(`Removed the voice-room skill copy at ${removeSkill(skillsDir([], env)).target}.`);
-  }
-  const running = await runningConnector(env);
-  if (running?.pid) {
-    try { process.kill(running.pid, 'SIGTERM'); done.push(`Stopped the connector (pid ${running.pid}${running.version ? ', version ' + running.version : ''}).`); }
-    catch (error) { next.push(`A connector is running (pid ${running.pid}) and could not be stopped (${error.code || error.message}); stop it yourself.`); }
-  }
-  if (!fromSource(env) && existsSync(copiesDir(env))) { rmSync(copiesDir(env), { recursive: true, force: true }); done.push(`Removed the installed copies under ${copiesDir(env)}.`); }
-  const dataDir = env.SIDEVOICE_DATA_DIR || path.join(os.homedir(), '.sidevoice');
-  const paired = pairedRoom(env);
-  if (existsSync(dataDir)) {
-    rmSync(dataDir, { recursive: true, force: true });
-    done.push(`Removed ${dataDir} (credential, socket, outbox, log).`);
-    if (paired) next.push(`The room at ${paired.origin} still lists this machine as paired (connector ${paired.connector_id}) until you revoke it from the room's page.`);
-  }
-  if (harnesses.includes('codex')) next.push(`Remove the [mcp_servers.sidevoice] table from ${env.CODEX_HOME || path.join(os.homedir(), '.codex')}/config.toml — it is machine-wide and this package does not rewrite it.`);
-  next.push('Sessions already open keep their MCP server until they end.');
-  return { done, next };
-}
-
-if (process.env.SIDEVOICE_UNINSTALL_MAIN === '1') {
-  try {
-    const { done, next } = await uninstall();
-    for (const line of done) console.log('· ' + line);
-    if (next.length) { console.log('\nLeft for you:'); for (const line of next) console.log('\n' + line); }
-  } catch (error) { console.error(error.message); process.exit(1); }
-}
-
-if (process.env.SIDEVOICE_INSTALL_MAIN === '1') {
-  try {
-    const { done, next } = await install();
-    for (const line of done) console.log('· ' + line);
-    if (next.length) {
-      console.log('\nLeft for you:');
-      for (const line of next) console.log('\n' + line);
-    }
-  } catch (error) { console.error(error.message); process.exit(1); }
-}

package/mcp.mjs

@@ -1,222 +0,0 @@
-#!/usr/bin/env node
-/** Stdio MCP façade for one conversation. It holds no connection to the room: it starts or reuses
- *  the host's connector and keeps one local connection to it for as long as this session lives. */
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { advertisedCapabilities, capabilityState, SUPPORTED } from './harness-contract.mjs';
-import { harnessFor, identifyHarness } from './harnesses.mjs';
-import { pair, pairedRoom } from './pair.mjs';
-import { readFileSync } from 'node:fs';
-
-const VERSION = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version;
-
-const dataDir = process.env.SIDEVOICE_DATA_DIR || path.join(os.homedir(), '.sidevoice');
-const socketPath = process.env.SIDEVOICE_CONNECTOR_SOCKET || path.join(dataDir, 'connector.sock');
-const connectorPath = fileURLToPath(new URL('./connector.mjs', import.meta.url));
-
-// Claude Code keeps at most 2048 characters of these; the rest is cut (measured 2026-09-21).
-const INSTRUCTIONS = `Sidevoice connects this conversation to the user's voice room.
-- Call voice_connect only when the user asks to join the room or enable voice; never as a side effect.
-- Voice input is a user message: a JSON header ({"channel":"voice","session_id","revision","message_id"}), the user's literal words, then a [Sidevoice] line that is not the user's. The header is opaque reply metadata. A repeated message_id is a redelivery: do not act on it again.
-- Reply by voice with voice_say, using that message's session_id and revision for every publication. For substantive work: first a short acknowledgement (what you understood, what you will do next), then meaningful checkpoints, then the result. No filler, no narrating tool calls. Publish questions too, and wait.
-- Between steps, at each tool result, take in newly arrived user input before starting the next step: an addition, a refinement or a replacement, by its meaning. Drop obsolete work not yet started; keep what remains useful; say what you now understand. No artificial pauses.
-- "published" means the room stored it, not that the user heard it. If publishing fails, continue in writing.
-- If the user closes this conversation's voice from the room, voice_say fails saying so: continue in writing, do not retry, and call voice_connect again only if asked.
-- Pairing is the user's act. If voice_connect says this machine is not paired with the room, ask the user for the room's address and the one-time code the room shows under "Emparejar conector", then call voice_pair and voice_connect again. Never try to obtain a code from the room yourself.
-- If voice_connect returns inbound.ok false, voice will look sent and never arrive: tell the user inbound.reason, offer inbound.remedy in your own words including the safeguard the machine-wide option removes, and change no settings unasked.
-- Read receipts and working state need nothing from you: the room observes what the harness records.`;
-
-// ----- one persistent connection to the connector -----
-let ipc = null, ipcBuffer = '', ipcSerial = 0;
-const ipcWaiting = new Map();
-function connectIpc() {
-  return new Promise((resolve, reject) => {
-    const socket = net.createConnection(socketPath);
-    socket.once('error', reject);
-    socket.on('connect', () => {
-      socket.removeListener('error', reject);
-      socket.on('error', () => {});
-      socket.on('close', () => { if (ipc === socket) ipc = null; for (const w of ipcWaiting.values()) w.reject(new Error('Connector went away')); ipcWaiting.clear(); });
-      socket.on('data', chunk => {
-        ipcBuffer += chunk; let index;
-        while ((index = ipcBuffer.indexOf('\n')) >= 0) {
-          const line = ipcBuffer.slice(0, index); ipcBuffer = ipcBuffer.slice(index + 1);
-          let reply; try { reply = JSON.parse(line); } catch { continue; }
-          const waiting = ipcWaiting.get(reply.id); if (!waiting) continue; ipcWaiting.delete(reply.id);
-          reply.ok ? waiting.resolve(reply.result) : waiting.reject(new Error(reply.error));
-        }
-      });
-      ipc = socket; resolve(socket);
-    });
-  });
-}
-async function ensureConnector() {
-  if (ipc) return ipc;
-  try { return await connectIpc(); } catch {}
-  const child = spawn(process.execPath, [connectorPath], { detached: true, stdio: 'ignore', env: process.env });
-  child.unref();
-  for (let attempt = 0; attempt < 40; attempt++) {
-    await new Promise(r => setTimeout(r, 100));
-    try { return await connectIpc(); } catch {}
-  }
-  throw new Error('The Sidevoice connector did not start (is this host paired? see docs/INSTALL.md)');
-}
-async function rpc(method, params) {
-  await ensureConnector();
-  const id = ++ipcSerial;
-  return new Promise((resolve, reject) => { ipcWaiting.set(id, { resolve, reject }); ipc.write(JSON.stringify({ id, method, params }) + '\n'); });
-}
-
-// ----- tools -----
-const tools = [
-  { name: 'voice_connect', description: 'Connect this conversation to the voice room. Only on an explicit request to join or enable voice. Fails, saying what to ask the user, when this machine is not paired with the room.',
-    inputSchema: { type: 'object', properties: { title: { type: 'string', description: 'Short label for this conversation in the room' }, room: { type: 'string', description: 'The room\'s address (https://…) when the user names one; omitted, the room this machine is paired with' } }, additionalProperties: false } },
-  { name: 'voice_pair', description: 'Pair this machine with a room using the one-time code the user read from the room\'s interface ("Emparejar conector"). Only with a code the user gave you; one room per machine, a new pairing replaces the previous one.',
-    inputSchema: { type: 'object', properties: { room: { type: 'string', description: 'The room\'s address (https://…)' }, code: { type: 'string', description: 'The one-time pairing code shown by the room' } }, required: ['room', 'code'], additionalProperties: false } },
-  { name: 'voice_say', description: 'Publish a concise spoken version of your reply to the room, with the session_id and revision from the voice message header.',
-    inputSchema: { type: 'object', properties: { text: { type: 'string' }, session_id: { type: 'string' }, revision: { type: 'integer', minimum: 0 }, utterance_id: { type: 'string' }, language: { type: 'string', enum: ['es', 'en', 'fr', 'it', 'pt', 'hi'] } }, required: ['text', 'session_id', 'revision'], additionalProperties: false } },
-  { name: 'voice_disconnect', description: 'Leave the voice room. The conversation and its work continue in writing.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
-  { name: 'voice_status', description: 'Whether the room can currently reach this conversation.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
-];
-/** The joining steps as a prompt: what the voice-room skill used to be, now carried by the server itself so
- *  nothing is copied into any harness and the steps move with the version. */
-const PROMPTS = [{
-  name: 'voice-room',
-  description: 'Join the user\'s Sidevoice voice room with this conversation.',
-  arguments: [{ name: 'title', description: 'Title for this conversation in the room', required: false }],
-}];
-function promptText(args = {}) {
-  const title = (args.title || '').trim();
-  return [
-    'Join the voice room for this conversation and keep it reachable.',
-    '',
-    '1. Call voice_status. If it reports joined and room_reachable, say so in one line and stop.',
-    `2. Call voice_connect with the title ${title ? JSON.stringify(title) : 'a short label of what this conversation is about'}. If the user named a room, pass its address as room.`,
-    '   If it fails saying this machine is not paired with the room (or is paired with a different one), ask the user for the room\'s address and the one-time code the room shows them under "Emparejar conector"; call voice_pair with both, then voice_connect again. Never try to get a code from the room yourself.',
-    '3. Tell the user in one line whether the room can reach this conversation. If inbound.ok is false, relay inbound.reason and offer inbound.remedy in your own words, including what safeguard it removes; change nothing yourself.',
-    '',
-    'Nothing else is registered: the room learns that a message was read and whether this conversation is working from what the harness itself records about it. How to behave once joined is in this server\'s instructions.',
-  ].join('\n');
-}
-let binding = null;
-function originOf(room) {
-  try { return new URL(room).origin; } catch { throw new Error(`"${room}" is not a room address; expected something like https://voice.example`); }
-}
-/** Ask the user, do not guess: the code exists only on the room's screen. */
-function pairingNeeded(room, paired) {
-  const target = room ? originOf(room) : null;
-  if (!paired) return `This machine is not paired with ${target ? 'the room at ' + target : 'any room'}. Ask the user for the room's address${target ? ' (confirm ' + target + ')' : ''} and the one-time pairing code the room shows under "Emparejar conector", then call voice_pair with both. Do not fetch a code yourself.`;
-  if (target && target !== paired.origin) return `This machine is paired with ${paired.origin}, not ${target}. One room per machine: to switch, ask the user for the pairing code that ${target} shows under "Emparejar conector" and call voice_pair (it replaces the current pairing); to stay, call voice_connect without a room.`;
-  return null;
-}
-/** A connector from another version serves this conversation with that version's behaviour. */
-function versionNote(connectorVersion) {
-  if (!ipc || connectorVersion === VERSION) return {};
-  return { note: `The connector running on this machine is ${connectorVersion ? 'version ' + connectorVersion : 'older than this server'}; this conversation runs ${VERSION}. It exits 15 s after the last conversation leaves it; until then behaviour is that version's.` };
-}
-function inboundFor(harness, thread) {
-  return capabilityState(harness, 'inspectInbound') === SUPPORTED ? harness.inspectInbound(thread) : null;
-}
-async function invoke(name, args, meta) {
-  if (name === 'voice_status') {
-    const status = ipc ? await rpc('status', {}) : { connected: false, bindings: [], closed_by_room: [] };
-    // The room may have closed this conversation's voice since we joined: the connector is the truth.
-    const closed = !!binding && (status.closed_by_room || []).includes(binding.client_ref);
-    if (closed) binding = null;
-    const module = binding ? harnessFor(binding.harness) : null;
-    const inbound = binding ? inboundFor(module, binding.client_ref) : null;
-    return { joined: !!binding, room: status.room || pairedRoom()?.origin || null, room_reachable: status.connected, room_error: status.room_error || null, socket_error: status.socket_error || null,
-             version: VERSION, connector_version: status.version || null, ...versionNote(status.version),
-             binding_id: binding?.binding_id || null, harness: binding?.harness || null,
-             capabilities: binding?.capabilities || null, inbound,
-             ...(closed ? { closed_by_room: true, note: 'The user closed this conversation\'s voice channel from the room. Continue in writing; call voice_connect again only if they ask for voice.' } : {}) };
-  }
-  if (name === 'voice_pair') {
-    if (!args.room || !args.code) throw new Error('voice_pair needs the room\'s address and the code the user read from it.');
-    const previous = pairedRoom();
-    // The room shows the code in upper case and compares it that way; a dictated one arrives however it was heard.
-    const result = await pair(originOf(args.room), String(args.code).trim().toUpperCase());
-    // The connector that is up, if any, was started for the previous credential: let go of it so it can
-    // exit, and the next voice_connect starts one for this room. Other conversations still bound to the
-    // previous room keep that connector alive until they leave; they are not moved.
-    if (binding) { try { await rpc('unregister', { binding_id: binding.binding_id }); } catch {} binding = null; }
-    if (ipc) { ipc.end(); ipc = null; }
-    return { status: 'paired', room: result.origin, connector_id: result.connector_id,
-             ...(previous && previous.origin !== result.origin ? { replaced: previous.origin, note: 'Conversations on this machine still joined to the previous room keep it until they leave.' } : {}),
-             next: 'Call voice_connect to join.' };
-  }
-  if (name === 'voice_connect') {
-    const needed = pairingNeeded(args.room, pairedRoom());
-    if (needed) { const error = new Error(needed); error.data = { pairing_needed: true, room: args.room ? originOf(args.room) : null }; throw error; }
-    const who = identifyHarness(meta);
-    const title = (args.title || process.env.SIDEVOICE_TITLE || path.basename(process.cwd())).slice(0, 200);
-    // Refuse rather than join a room we cannot hear from: a conversation whose harness holds
-    // what the room posts would sit in the list looking present while the user talks to nobody.
-    const inbound = inboundFor(who.module, who.thread);
-    if (inbound?.ok === false) {
-      const error = new Error(`No se conecta esta conversación: ${inbound.reason} ${inbound.remedy}`);
-      error.data = { inbound };
-      throw error;
-    }
-    const capabilities = advertisedCapabilities(who.module);
-    // Which model is answering, read from the session's own launch line rather than asked of the model.
-    let engine = null;
-    try { engine = who.module.engine?.(who.thread) || null; } catch { engine = null; }
-    const result = await rpc('register', { client_ref: who.thread, harness: who.harness, thread: who.thread,
-      title, delivery: who.delivery, inbound, capabilities, engine });
-    binding = { ...result, harness: who.harness, client_ref: who.thread, capabilities };
-    let connectorVersion = null; try { connectorVersion = (await rpc('status', {})).version || null; } catch {}
-    return { status: result.pending ? 'joining' : 'joined', harness: who.harness, conversation: who.thread,
-             binding_id: result.binding_id, delivery: 'push', room_reachable: result.connected, capabilities, inbound,
-             version: VERSION, connector_version: connectorVersion, ...versionNote(connectorVersion) };
-  }
-  if (!binding) throw new Error('Not connected to the voice room: call voice_connect first (only if the user asked).');
-
-  if (name === 'voice_say') {
-    let result;
-    try {
-      result = await rpc('publish', { binding_id: binding.binding_id, client_ref: binding.client_ref, text: args.text, session_id: args.session_id, revision: args.revision, utterance_id: args.utterance_id, language: args.language });
-    } catch (error) {
-      if (error.message === 'CLOSED_BY_ROOM') {
-        binding = null;
-        throw new Error('The user closed this conversation\'s voice channel from the room. Continue in writing and do not publish speech; call voice_connect again only if the user asks for voice.');
-      }
-      throw error;
-    }
-    return result.text_saved ? { status: 'published', text_saved: true, audio: result.status, reason: result.reason } : result;
-  }
-  if (name === 'voice_disconnect') { const result = await rpc('unregister', { binding_id: binding.binding_id }); binding = null; return { status: 'left', room_reachable: result.connected }; }
-  throw new Error('Unknown tool');
-}
-
-// ----- JSON-RPC over stdio -----
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', async chunk => {
-  input += chunk;
-  while (input.includes('\n')) {
-    const index = input.indexOf('\n'); const line = input.slice(0, index); input = input.slice(index + 1);
-    if (!line.trim()) continue;
-    let request; try { request = JSON.parse(line); } catch { continue; }
-    if (request.id === undefined) continue; // notifications need no answer
-    let result, error;
-    try {
-      if (request.method === 'initialize') result = { protocolVersion: request.params?.protocolVersion || '2025-06-18', capabilities: { tools: {}, prompts: {} }, serverInfo: { name: 'sidevoice', version: VERSION }, instructions: INSTRUCTIONS };
-      else if (request.method === 'prompts/list') result = { prompts: PROMPTS };
-      else if (request.method === 'prompts/get') {
-        if (request.params?.name !== 'voice-room') throw Object.assign(new Error('Unknown prompt'), { code: -32602 });
-        result = { description: PROMPTS[0].description, messages: [{ role: 'user', content: { type: 'text', text: promptText(request.params?.arguments) } }] };
-      }
-      else if (request.method === 'tools/list') result = { tools };
-      else if (request.method === 'tools/call') { const value = await invoke(request.params.name, request.params.arguments || {}, request.params._meta); result = { content: [{ type: 'text', text: JSON.stringify(value) }] }; }
-      else if (request.method === 'ping') result = {};
-      else throw Object.assign(new Error('Method not found'), { code: -32601 });
-    } catch (e) { error = { code: e.code || -32603, message: e.message }; }
-    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, ...(error ? { error } : { result }) }) + '\n');
-  }
-});
-process.stdin.on('end', () => { ipc?.end(); process.exit(0); });

package/pair.mjs

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-/** One-time pairing: redeem the code shown by the room for this host's connector credential.
- *
- *  The code is the room's to give and the person's to carry: the room shows it to whoever is in it
- *  ("Emparejar conector"), and only that person can hand it to this machine. Nothing here asks the
- *  room for one — a caller that could would turn "you can reach the address" into "you are in the room". */
-import os from 'node:os';
-import path from 'node:path';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-
-export function dataDir(env = process.env) {
-  return env.SIDEVOICE_DATA_DIR || path.join(os.homedir(), '.sidevoice');
-}
-
-/** Where a plaintext connection is acceptable: the token must never cross a network we do not own. Loopback,
- *  and a Kubernetes service name (`<svc>.<ns>.svc`, `<svc>.<ns>.svc.<cluster domain>`), which by construction
- *  resolves only inside the cluster and is routed there. Anything else — a private IP included — needs TLS: a
- *  host we cannot classify is not a reason to send a credential in clear. */
-export function privateNetwork(hostname) {
-  if (['127.0.0.1', 'localhost', '::1', '[::1]'].includes(hostname)) return true;
-  return /^[a-z0-9-]+\.[a-z0-9-]+\.svc(\.[a-z0-9.-]+)?$/i.test(hostname);
-}
-
-/** The room's http(s) origin from the socket address the credential stores. */
-export function roomOrigin(wsUrl) {
-  const url = new URL(wsUrl); url.protocol = url.protocol === 'wss:' ? 'https:' : 'http:'; return url.origin;
-}
-
-/** Which room this machine is paired with, or null. */
-export function pairedRoom(env = process.env) {
-  try {
-    const saved = JSON.parse(readFileSync(path.join(dataDir(env), 'credentials.json'), 'utf8'));
-    if (!saved.url || !saved.connector_id || !saved.token) return null;
-    return { origin: roomOrigin(saved.url), connector_id: saved.connector_id };
-  } catch { return null; }
-}
-
-/** Redeem a code for this host's credential. Returns where it was written. */
-export async function pair(room, code, env = process.env) {
-  const base = new URL(room);
-  if (base.protocol !== 'https:' && !privateNetwork(base.hostname)) {
-    throw new Error(`${base.origin} is reached in clear over a network this machine does not own; the room must be https:// there (loopback and Kubernetes service names are the exceptions).`);
-  }
-  const response = await fetch(new URL('/api/connectors/pair', base), {
-    method: 'POST', headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ code, host: os.hostname() }), signal: AbortSignal.timeout(15_000),
-  });
-  const body = await response.json().catch(() => ({}));
-  if (!response.ok) throw new Error('Pairing failed: ' + (body.detail || response.status));
-  const ws = new URL('/api/connectors/ws', base); ws.protocol = base.protocol === 'https:' ? 'wss:' : 'ws:';
-  const directory = dataDir(env);
-  mkdirSync(directory, { recursive: true, mode: 0o700 });
-  const file = path.join(directory, 'credentials.json');
-  writeFileSync(file, JSON.stringify({ url: ws.toString(), connector_id: body.connector_id, token: body.token, protocol: body.protocol }, null, 2), { mode: 0o600 });
-  return { file, connector_id: body.connector_id, origin: base.origin };
-}
-
-if (process.env.SIDEVOICE_PAIR_MAIN === '1') {
-  const [room, code] = process.argv.slice(2);
-  if (!room || !code) { console.error('usage: sidevoice pair <room-url> <pairing-code>   (the code is shown in the room under "Emparejar conector")'); process.exit(2); }
-  try {
-    const result = await pair(room, code);
-    console.log(`Paired with ${result.origin} as connector ${result.connector_id}; credential saved to ${result.file}`);
-  } catch (error) { console.error(error.message); process.exit(1); }
-}

package/skill.mjs

@@ -1,41 +0,0 @@
-/** `sidevoice skill remove|status [--dir <skills dir>]`: the voice-room skill is no longer installed — the
- *  server carries the same steps as an MCP prompt — but copies from earlier versions are still on disk, and
- *  this takes ours away. A directory of the same name that is not ours is never touched. */
-import { existsSync, readFileSync, rmSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-export const SKILL_NAME = 'voice-room';
-const MARKER = 'sidevoice: installed copy';
-
-export function skillsDir(argv = process.argv.slice(2), env = process.env) {
-  const index = argv.indexOf('--dir');
-  if (index >= 0 && argv[index + 1]) return path.resolve(argv[index + 1]);
-  return path.join(env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'), 'skills');
-}
-
-export function status(dir) {
-  const target = path.join(dir, SKILL_NAME);
-  const manifest = path.join(target, 'SKILL.md');
-  if (!existsSync(target)) return { state: 'absent', target };
-  let ours = false;
-  try { ours = readFileSync(manifest, 'utf8').includes(MARKER); } catch {}
-  return { state: ours ? 'installed' : 'foreign', target };
-}
-
-export function remove(dir) {
-  const current = status(dir);
-  if (current.state === 'foreign') throw new Error(`${current.target} is not Sidevoice's skill; left as it is.`);
-  if (current.state === 'installed') rmSync(current.target, { recursive: true, force: true });
-  return { state: 'absent', target: current.target, action: current.state === 'installed' ? 'removed' : 'nothing to remove' };
-}
-
-if (process.env.SIDEVOICE_SKILL_MAIN === '1') {
-  const [command] = process.argv.slice(2);
-  const dir = skillsDir();
-  try {
-    const result = command === 'remove' ? remove(dir) : command === 'status' ? status(dir) : null;
-    if (!result) { console.error('usage: sidevoice skill <remove|status> [--dir <skills dir>]   (the skill is no longer installed: the MCP server offers the voice-room prompt)'); process.exit(2); }
-    console.log(`${result.action || result.state}: ${result.target}`);
-  } catch (error) { console.error(error.message); process.exit(1); }
-}