@sidevoice/uplink 0.4.2 → 0.5.0

package/harness-codex.mjs

@@ -1,126 +0,0 @@
-/** Codex harness implementation.
- *
- * Delivery and identity are available to the stdio MCP façade. Working state and read receipts come
- * from the thread's own rollout file, which Codex appends as the turn runs; nothing is configured in Codex. */
-import { execFile } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { defineHarness, envelope, SUPPORTED, UNSUPPORTED, tailJsonl } from './harness-contract.mjs';
-
-function turnMetadata(meta) {
-  let turn = meta?.['x-codex-turn-metadata'] || {};
-  if (typeof turn === 'string') {
-    try { turn = JSON.parse(turn); } catch { turn = {}; }
-  }
-  return turn;
-}
-
-function sessionIdentity({ meta, env = process.env, payload } = {}) {
-  const turn = turnMetadata(meta);
-  const thread = meta?.['openai/threadId'] || meta?.['openai/thread_id'] || meta?.codexThreadId
-    || meta?.codex_thread_id || turn.thread_id || payload?.session_id || payload?.thread_id
-    || env.CODEX_THREAD_ID;
-  if (!thread) return null;
-  const delivery = env.SIDEVOICE_DELIVERY_URL
-    ? { kind: 'http', url: env.SIDEVOICE_DELIVERY_URL, thread }
-    : { kind: 'codex-queue', thread };
-  return { harness: 'codex', thread, delivery };
-}
-
-function deliver(delivery, event) {
-  if (delivery?.kind === 'http') {
-    return fetch(delivery.url, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ thread_id: delivery.thread, text: event.text, message_id: event.message_id,
-        session_id: event.session_id, revision: event.revision, channel: event.channel || 'voice' }),
-      signal: AbortSignal.timeout(30_000),
-    }).then(async response => {
-      if (!response.ok) throw new Error(`Harness delivery failed (${response.status})`);
-      return { status: 'accepted', detail: `receiver answered ${response.status}` };
-    });
-  }
-  if (delivery?.kind !== 'codex-queue') throw new Error(`Unsupported Codex delivery kind: ${delivery?.kind}`);
-  return new Promise((resolve, reject) => {
-    const binary = process.env.SIDEVOICE_CODEX_BIN || 'codex';
-    const args = ['queue', '--thread', delivery.thread, '--message', envelope(event)];
-    execFile(binary, args, { timeout: 30_000, maxBuffer: 1 << 20 }, (error, stdout, stderr) => {
-      if (error) return reject(new Error((stderr || stdout || error.message).toString().trim().slice(0, 400)));
-      resolve({ status: 'accepted', detail: 'codex queue confirmed the thread' });
-    });
-  });
-}
-
-/** Which model this thread runs, from the launch line of the process that owns it, when it says. */
-function engine(thread, env = process.env) {
-  const named = env.CODEX_MODEL || null;
-  return named ? { model: named, effort: env.CODEX_REASONING_EFFORT || null, thinking: null } : null;
-}
-
-const codexHome = () => process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-
-/** The rollout Codex writes for a thread: `sessions/YYYY/MM/DD/rollout-<stamp>-<thread id>.jsonl`. Found by
- *  its name, newest day first, so nothing has to be asked of Codex's database. */
-export function rolloutPath(threadId) {
-  const root = path.join(codexHome(), 'sessions');
-  const list = dir => { try { return readdirSync(dir).sort().reverse(); } catch { return []; } };
-  for (const year of list(root)) for (const month of list(path.join(root, year))) for (const day of list(path.join(root, year, month))) {
-    const dir = path.join(root, year, month, day);
-    const file = list(dir).find(name => name.endsWith('-' + threadId + '.jsonl'));
-    if (file) return path.join(dir, file);
-  }
-  return null;
-}
-
-/** What one rollout line says, in the terms of the contract: a working transition, a user message, or nothing. */
-export function interpretRollout(entry, state = {}) {
-  const payload = entry?.payload || {};
-  if (entry?.type === 'event_msg') {
-    if (payload.type === 'task_started' && payload.turn_id) { state.turn_id = payload.turn_id; return { working: true, turn_id: payload.turn_id }; }
-    if ((payload.type === 'task_complete' || payload.type === 'turn_aborted') && payload.turn_id) {
-      if (state.turn_id === payload.turn_id) state.turn_id = null;
-      return { working: false, turn_id: payload.turn_id };
-    }
-    return null;
-  }
-  if (entry?.type === 'response_item' && payload.type === 'message' && payload.role === 'user') {
-    const text = (payload.content || []).filter(part => part?.type === 'input_text').map(part => part.text).join('\n');
-    return text ? { text, turn_id: state.turn_id || null } : null;
-  }
-  return null;
-}
-
-const POLL_MS = Number(process.env.SIDEVOICE_WORK_POLL_MS || 400);
-
-/** Watch one thread through its rollout: task_started/task_complete are the turn, a user message is the
- *  moment the thread took it (a queued message is written when the turn starts on it). What the rollout
- *  already holds is read first, silently, so a turn that was running before we looked is reported as
- *  running — old messages are not re-read. */
-export function observe(threadId, handlers) {
-  const state = {};
-  let working = null;
-  return tailJsonl(() => rolloutPath(threadId), (entry, replayed) => {
-    const seen = interpretRollout(entry, state);
-    if (!seen) return;
-    if (typeof seen.working === 'boolean') { working = seen.working; if (!replayed) handlers.working(seen.working, { turn_id: seen.turn_id }); }
-    else if (!replayed) handlers.userMessage({ text: seen.text, turn_id: seen.turn_id });
-  }, { intervalMs: POLL_MS, catchUp: true, caughtUp: () => { if (working !== null) handlers.working(working, { turn_id: working ? state.turn_id : null }); } });
-}
-
-export const codexHarness = defineHarness({
-  name: 'codex',
-  capabilities: {
-    deliver: SUPPORTED,
-    inspectInbound: UNSUPPORTED,
-    working: SUPPORTED,
-    endOfTurn: SUPPORTED,
-    sessionIdentity: SUPPORTED,
-  },
-  deliver,
-  engine,
-  observe,
-  sessionIdentity,
-});
-
-export default codexHarness;

package/harness-contract.mjs

@@ -1,116 +0,0 @@
-/** The harness boundary. A known harness declares every capability; callers never infer support
- *  from a missing method. Missing or malformed declarations remain unknown, never false. */
-
-export const CAPABILITIES = Object.freeze([
-  'deliver',
-  'inspectInbound',
-  'working',
-  'endOfTurn',
-  'sessionIdentity',
-]);
-
-export const SUPPORTED = 'supported';
-export const UNSUPPORTED = 'unsupported';
-export const UNKNOWN = 'unknown';
-const DECLARED_STATES = new Set([SUPPORTED, UNSUPPORTED]);
-
-export function capabilityState(harness, capability) {
-  const state = harness?.capabilities?.[capability];
-  return DECLARED_STATES.has(state) ? state : UNKNOWN;
-}
-
-export function advertisedCapabilities(harness) {
-  return Object.fromEntries(CAPABILITIES.map(capability => [capability, capabilityState(harness, capability)]));
-}
-
-/** `working` and `endOfTurn` are both answered by observation: a harness that supports either
- *  implements `observe(thread, handlers)`, which watches what the harness itself writes about that
- *  conversation and calls back — `working(bool, { turn_id })` on every transition it can see, and
- *  `userMessage({ text, turn_id })` for every user message the conversation admits. It returns a
- *  function that stops watching. Nothing is installed in the harness for this to work. */
-export function defineHarness(definition) {
-  if (!definition?.name) throw new Error('A harness needs a name');
-  for (const capability of CAPABILITIES) {
-    const state = definition.capabilities?.[capability];
-    if (!DECLARED_STATES.has(state)) throw new Error(`${definition.name} must declare ${capability}`);
-    const implemented = capability === 'working' || capability === 'endOfTurn' ? definition.observe : definition[capability];
-    if (state === SUPPORTED && typeof implemented !== 'function') {
-      throw new Error(`${definition.name} declares ${capability} supported but does not implement it`);
-    }
-  }
-  return Object.freeze({ ...definition, capabilities: Object.freeze({ ...definition.capabilities }) });
-}
-
-/** The header before the user's literal words, and — for a voice message — the note after them that
- *  asks the conversation to speak first. The note travels inside the message because it is the only
- *  thing every harness delivers without anything installed; the instructions name it as not the user's. */
-export function envelope(event) {
-  const header = {
-    channel: event.channel === 'room-control' ? 'room-control' : 'voice',
-    session_id: event.session_id,
-    revision: event.revision,
-    message_id: event.message_id,
-  };
-  const note = header.channel === 'voice' ? '\n\n' + nudge(header) : '';
-  return JSON.stringify(header) + '\n\n' + event.text + note;
-}
-
-/** What the conversation is asked at the moment it reads a voice message. */
-export function nudge(header) {
-  return `[Sidevoice] A voice message from the room (session_id "${header.session_id}", revision ${header.revision}). `
-    + 'Before any other tool, publish a short spoken acknowledgement with voice_say that says what you understood and what you will do next, '
-    + 'using that session_id and revision; then continue the work and publish the result by voice as well.';
-}
-
-/** The header at the front of a delivered message, or null when the text is not one of ours. Works on
- *  the text as a harness stores it, which may put its own line before the header. */
-export function voiceEnvelope(text) {
-  if (typeof text !== 'string') return null;
-  const start = text.indexOf('{"channel":');
-  if (start < 0) return null;
-  const end = text.indexOf('}', start);
-  if (end < 0) return null;
-  let header;
-  try { header = JSON.parse(text.slice(start, end + 1)); } catch { return null; }
-  if (!header || (header.channel !== 'voice' && header.channel !== 'room-control') || !header.message_id || !header.session_id || !Number.isInteger(header.revision)) return null;
-  return { channel: header.channel, message_id: header.message_id, session_id: header.session_id, revision: header.revision };
-}
-
-/** Follows a JSON-lines file the harness appends to: each complete new line is handed to `onLine` as
- *  parsed JSON. From where the file is now, unless `catchUp` is set — then what is already there is
- *  read first, with `replayed = true`, so a watcher can learn the current state without mistaking old
- *  lines for news. The file may not exist yet — `locate` is asked again until it does. */
-export function tailJsonl(locate, onLine, { intervalMs = 400, catchUp = false, caughtUp = () => {} } = {}) {
-  let file = null, offset = null, remainder = '', replaying = false;
-  const poll = async () => {
-    const { statSync, openSync, readSync, closeSync } = await import('node:fs');
-    if (!file) { file = locate(); if (!file) return; }
-    let size;
-    try { size = statSync(file).size; } catch { file = null; offset = null; return; }
-    if (offset === null) {
-      if (!catchUp) { offset = size; return; }                // start at the end: only what happens from now on
-      offset = 0; replaying = true;
-    }
-    if (size < offset) { offset = 0; remainder = ''; }        // rewritten: read it again from the top
-    if (size === offset) return;
-    const fd = openSync(file, 'r');
-    try {
-      const buffer = Buffer.alloc(size - offset);
-      readSync(fd, buffer, 0, buffer.length, offset);
-      offset = size;
-      remainder += buffer.toString('utf8');
-    } finally { closeSync(fd); }
-    let index;
-    while ((index = remainder.indexOf('\n')) >= 0) {
-      const line = remainder.slice(0, index); remainder = remainder.slice(index + 1);
-      if (!line.trim()) continue;
-      let parsed; try { parsed = JSON.parse(line); } catch { continue; }
-      try { onLine(parsed, replaying); } catch {}
-    }
-    if (replaying) { replaying = false; try { caughtUp(); } catch {} }
-  };
-  const timer = setInterval(() => { poll().catch(() => {}); }, intervalMs);
-  timer.unref?.();
-  poll().catch(() => {});
-  return () => clearInterval(timer);
-}

package/harness-http.mjs

@@ -1,39 +0,0 @@
-/** Generic HTTP harness used by explicitly configured external receivers. */
-import { defineHarness, SUPPORTED, UNSUPPORTED } from './harness-contract.mjs';
-
-async function deliver(delivery, event) {
-  if (delivery?.kind !== 'http') throw new Error(`Unsupported HTTP delivery kind: ${delivery?.kind}`);
-  const response = await fetch(delivery.url, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ thread_id: delivery.thread, text: event.text, message_id: event.message_id,
-      session_id: event.session_id, revision: event.revision, channel: event.channel || 'voice' }),
-    signal: AbortSignal.timeout(30_000),
-  });
-  if (!response.ok) throw new Error(`Harness delivery failed (${response.status})`);
-  return { status: 'accepted', detail: `receiver answered ${response.status}` };
-}
-
-function sessionIdentity({ env = process.env } = {}) {
-  if (!env.SIDEVOICE_THREAD || !env.SIDEVOICE_DELIVERY_URL) return null;
-  return {
-    harness: env.SIDEVOICE_HARNESS || 'http',
-    thread: env.SIDEVOICE_THREAD,
-    delivery: { kind: 'http', url: env.SIDEVOICE_DELIVERY_URL, thread: env.SIDEVOICE_THREAD },
-  };
-}
-
-export const httpHarness = defineHarness({
-  name: 'http',
-  capabilities: {
-    deliver: SUPPORTED,
-    inspectInbound: UNSUPPORTED,
-    working: UNSUPPORTED,
-    endOfTurn: UNSUPPORTED,
-    sessionIdentity: SUPPORTED,
-  },
-  deliver,
-  sessionIdentity,
-});
-
-export default httpHarness;

package/harnesses.mjs

@@ -1,19 +0,0 @@
-/** Registry and selection for the harness modules. The façade and connector ask this registry;
- *  neither contains harness-name branches. */
-import { claudeHarness } from './harness-claude.mjs';
-import { codexHarness } from './harness-codex.mjs';
-import { httpHarness } from './harness-http.mjs';
-
-export const harnesses = Object.freeze({ claude: claudeHarness, codex: codexHarness, http: httpHarness });
-
-export function harnessFor(name) {
-  return harnesses[name] || httpHarness;
-}
-
-export function identifyHarness(meta, env = process.env) {
-  for (const harness of [claudeHarness, codexHarness, httpHarness]) {
-    const identity = harness.sessionIdentity({ meta, env });
-    if (identity?.delivery) return { ...identity, module: harness };
-  }
-  throw new Error('Cannot tell which conversation this is: not launched by Claude Code or Codex, and no SIDEVOICE_THREAD/SIDEVOICE_DELIVERY_URL set');
-}

package/install.mjs

@@ -1,212 +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 { install as installSkill, skillsDir } 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);
-    const outcome = installSkill(skillsDir([], env));
-    done.push(`Skill ${outcome.action} at ${outcome.target}.`);
-  }
-
-  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, run /voice-room to join the 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 can see the skill.');
-    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 };
-}
-
-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); }
-}