@sidevoice/uplink 0.2.0 → 0.4.0

package/skill.mjs

@@ -0,0 +1,57 @@
+/** `sidevoice skill install|remove|status [--dir <skills dir>]`: the Claude Code skill that joins the room
+ *  (`/voice-room`). One file; running install again repairs it. A directory of the same name that is not
+ *  ours is never touched. */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+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 install(dir) {
+  const current = status(dir);
+  if (current.state === 'foreign') throw new Error(`${current.target} already holds a skill that is not Sidevoice's; remove or rename it first.`);
+  mkdirSync(current.target, { recursive: true });
+  writeFileSync(path.join(current.target, 'SKILL.md'), readFileSync(path.join(here, 'skill', SKILL_NAME, 'SKILL.md'), 'utf8'));
+  for (const stale of ['hook.mjs', 'harness-contract.mjs', 'harnesses.mjs', 'harness-claude.mjs', 'harness-codex.mjs', 'harness-http.mjs']) {
+    rmSync(path.join(current.target, stale), { force: true });   // an older copy carried a hook runtime; it is gone
+  }
+  return { ...status(dir), action: current.state === 'installed' ? 'updated' : 'installed' };
+}
+
+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 === 'install' ? install(dir) : command === 'remove' ? remove(dir) : command === 'status' ? status(dir) : null;
+    if (!result) { console.error('usage: sidevoice skill <install|remove|status> [--dir <skills dir>]'); process.exit(2); }
+    console.log(`${result.action || result.state}: ${result.target}`);
+    if (result.action === 'installed' || result.action === 'updated') {
+      console.log('In Claude Code, /voice-room joins the room for that conversation. New sessions see the skill; a session already open needs a restart.');
+    }
+  } catch (error) { console.error(error.message); process.exit(1); }
+}

package/adapters.mjs

@@ -1,69 +0,0 @@
-/** The last mile, one function per harness. Each takes a binding's delivery target and a room event. */
-import net from 'node:net';
-import { execFile } from 'node:child_process';
-
-/** The header the skill expects before the user's literal words. */
-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 };
-  return JSON.stringify(header) + '\n\n' + event.text;
-}
-
-/** Claude Code: the session's own inbox socket, inherited by the façade that registered the binding.
- *  The inbox sends no acknowledgement, so this can never report more than what the wire showed:
- *  the peer hanging up right after the frames is the one observable sign of a refusal. */
-function deliverClaude(delivery, event) {
-  return new Promise((resolve, reject) => {
-    const started = Date.now();
-    const socket = net.createConnection(delivery.socket);
-    let settled = false, wrote = 0, replied = '';
-    const finish = (error, status, detail) => {
-      if (settled) return;
-      settled = true; clearTimeout(timer); socket.destroy();
-      if (error) return reject(error);
-      resolve({ status, detail: `${detail} after ${Date.now() - started}ms${replied ? ', peer said ' + replied.slice(0, 120) : ''}` });
-    };
-    const timer = setTimeout(() => finish(null, 'unknown', 'connection still open, no acknowledgement'), 1500);
-    socket.on('error', error => finish(error));
-    socket.on('data', chunk => { replied += chunk; });
-    socket.on('connect', () => {
-      socket.write(JSON.stringify({ type: 'auth', token: delivery.token }) + '\n');
-      socket.write(JSON.stringify({ type: 'user', message: { role: 'user', content: envelope(event) } }) + '\n');
-      wrote = Date.now();
-    });
-    // A hang-up right after the frames is how a refused auth or a closed inbox looks from here.
-    socket.on('close', () => finish(null, 'rejected', wrote ? 'peer closed the connection' : 'peer closed before the frames were written'));
-  });
-}
-
-/** Codex: `codex queue` enqueues the next user turn on the local app-server daemon. */
-function deliverCodex(delivery, event) {
-  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' });
-    });
-  });
-}
-
-/** Fallback: an HTTP receiver next to the harness (the slimmed Codex Desktop bridge speaks this). */
-async function deliverHttp(delivery, event) {
-  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}` };
-}
-
-export const adapters = { 'claude-uds': deliverClaude, 'codex-queue': deliverCodex, http: deliverHttp };
-
-export function deliver(delivery, event) {
-  const adapter = adapters[delivery?.kind];
-  if (!adapter) throw new Error(`Unknown delivery kind: ${delivery?.kind}`);
-  return adapter(delivery, event);
-}