lazyclaw 6.0.0 → 6.1.0

package/channels-signal/index.mjs

@@ -0,0 +1,69 @@
+// @lazyclaw/channel-signal
+//
+// Thin wrapper around `signal-cli` (external binary, must be installed
+// separately and linked to a registered account). Inbound polling uses
+// `signal-cli receive --json`; outbound uses `signal-cli send`.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { Channel } from '../channels/base.mjs';
+
+export class SignalChannel extends Channel {
+  constructor(opts = {}) {
+    super('signal');
+    this._binary = opts.binary || process.env.SIGNAL_CLI_BIN || 'signal-cli';
+    this._account = opts.account || process.env.SIGNAL_ACCOUNT || null;
+    this._receiver = null;
+    this._pollMs = opts.pollMs || 15000;
+  }
+
+  async start(handler, opts = {}) {
+    await super.start(handler, opts);
+    if (!this._account) throw new Error('SignalChannel: account (E.164) required');
+    this._receiver = setInterval(() => { this._pollOnce().catch(() => {}); }, this._pollMs);
+    this._receiver.unref?.();
+  }
+
+  async _pollOnce() {
+    const proc = spawn(this._binary, ['-a', this._account, 'receive', '--json'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let buf = '';
+    proc.stdout.on('data', (d) => { buf += d.toString('utf8'); });
+    await new Promise((resolve) => proc.on('exit', resolve));
+    for (const line of buf.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const evt = JSON.parse(line);
+        const env = evt.envelope || {};
+        const text = env.dataMessage?.message || '';
+        const from = env.source || env.sourceNumber;
+        if (!from || !text) continue;
+        const reply = await this._processInbound({
+          threadId: String(from), text, gateInput: { token: from },
+        });
+        if (reply) await this.send(from, reply);
+      } catch { /* skip malformed */ }
+    }
+  }
+
+  async send(threadId, text) {
+    const res = spawnSync(this._binary, ['-a', this._account, 'send', '-m', String(text), String(threadId)],
+      { stdio: ['ignore', 'pipe', 'pipe'] });
+    if (res.error && res.error.code === 'ENOENT') {
+      const err = new Error(`SIGNAL_CLI_MISSING: ${this._binary}`);
+      err.code = 'SIGNAL_CLI_MISSING';
+      throw err;
+    }
+    if (res.status !== 0) {
+      throw new Error(`signal-cli send exited ${res.status}: ${res.stderr?.toString('utf8') || ''}`);
+    }
+  }
+
+  async stop() {
+    if (this._receiver) clearInterval(this._receiver);
+    this._receiver = null;
+    await super.stop();
+  }
+}
+
+export function register({ addChannel }) {
+  addChannel('signal', (opts) => new SignalChannel(opts));
+}

package/channels-signal/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@lazyclaw/channel-signal",
+  "version": "0.1.0",
+  "description": "Signal channel plugin for lazyclaw v5 (signal-cli wrapper).",
+  "type": "module",
+  "main": "index.mjs",
+  "files": ["index.mjs"],
+  "peerDependencies": { "lazyclaw": ">=5.0.0" }
+}

package/channels-voice/index.mjs

@@ -0,0 +1,81 @@
+// @lazyclaw/channel-voice
+//
+// v5.0 scope per spec §0.2: TRANSCRIBE-ONLY. No TTS reply (deferred to v5.1).
+//
+// This channel does not own its own transport. It registers itself with
+// the Telegram and Discord plugins (and any other channel that exposes
+// a `onVoiceMemo` hook) and acts as the transcription pipeline.
+// Telegram/Discord call `voice.ingestVoiceMemo({threadId, audio, mime})`
+// when a voice memo arrives; the resulting text is forwarded through
+// this channel's handler and the text reply is sent on whichever channel
+// the user is currently bound to via channels/threads.mjs.
+
+import { Channel } from '../channels/base.mjs';
+
+export class VoiceChannel extends Channel {
+  constructor(opts = {}) {
+    super('voice');
+    this._transcribe = typeof opts.transcribe === 'function' ? opts.transcribe : null;
+  }
+
+  setTranscriber(fn) {
+    if (typeof fn !== 'function') throw new Error('setTranscriber: function required');
+    this._transcribe = fn;
+  }
+
+  async ingestVoiceMemo({ threadId, audio, mime }) {
+    if (!this._transcribe) {
+      const err = new Error('TRANSCRIBE_NOT_CONFIGURED');
+      err.code = 'TRANSCRIBE_NOT_CONFIGURED';
+      throw err;
+    }
+    if (!Buffer.isBuffer(audio)) {
+      throw new Error('ingestVoiceMemo: audio must be a Buffer');
+    }
+    const text = await this._transcribe(audio, mime || 'audio/ogg');
+    if (!text || typeof text !== 'string') return null;
+    return await this._processInbound({
+      threadId: String(threadId), text, gateInput: { token: 'voice' },
+    });
+  }
+
+  // send() is intentionally a no-op text passthrough — voice channel does
+  // not synthesise audio in v5.0. The text reply is delivered by whichever
+  // channel the thread is bound to (channels/threads.mjs).
+  async send(_threadId, _text) {
+    // no-op
+  }
+}
+
+/**
+ * Default transcriber backed by an OpenAI-Whisper-compatible endpoint
+ * (e.g. OpenAI /v1/audio/transcriptions or any compatible proxy). Used
+ * by the registered factory when the host does not inject one.
+ */
+export function makeOpenAITranscriber({ apiKey, model = 'whisper-1', baseUrl = 'https://api.openai.com/v1' }) {
+  if (!apiKey) throw new Error('makeOpenAITranscriber: apiKey required');
+  return async function transcribe(audio, mime) {
+    const fd = new FormData();
+    const ext = (mime || '').split('/')[1] || 'ogg';
+    fd.append('file', new Blob([audio], { type: mime || 'audio/ogg' }), `memo.${ext}`);
+    fd.append('model', model);
+    const res = await fetch(`${baseUrl}/audio/transcriptions`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${apiKey}` },
+      body: fd,
+    });
+    if (!res.ok) throw new Error(`transcribe HTTP ${res.status}: ${await res.text()}`);
+    const j = await res.json();
+    return j.text || '';
+  };
+}
+
+export function register({ addChannel }) {
+  addChannel('voice', (opts) => {
+    const ch = new VoiceChannel(opts || {});
+    if (!opts?.transcribe && opts?.openai?.apiKey) {
+      ch.setTranscriber(makeOpenAITranscriber(opts.openai));
+    }
+    return ch;
+  });
+}

package/channels-voice/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@lazyclaw/channel-voice",
+  "version": "0.1.0",
+  "description": "Voice memo channel for lazyclaw v5 (transcribe-only; TTS deferred to v5.1).",
+  "type": "module",
+  "main": "index.mjs",
+  "files": ["index.mjs"],
+  "peerDependencies": { "lazyclaw": ">=5.0.0" }
+}

package/channels-whatsapp/index.mjs

@@ -0,0 +1,70 @@
+// @lazyclaw/channel-whatsapp
+//
+// whatsapp-web.js (browser automation). First-run prints a QR via
+// qrcode-terminal; subsequent runs reuse LocalAuth session in
+// <configDir>/whatsapp/. Inbound `message` events route to handler.
+
+import { Channel } from '../channels/base.mjs';
+
+export class WhatsappChannel extends Channel {
+  constructor(opts = {}) {
+    super('whatsapp');
+    this._opts = opts || {};
+    this._client = null;
+    this._qrState = 'pending'; // pending | shown | authenticated | failed
+    this._lastQr = null;
+  }
+
+  qrState() { return this._qrState; }
+  lastQr() { return this._lastQr; }
+
+  async start(handler, opts = {}) {
+    await super.start(handler, opts);
+    const wweb = await import('whatsapp-web.js');
+    const qrt = await import('qrcode-terminal');
+    const { Client, LocalAuth } = wweb;
+    this._client = new Client({
+      authStrategy: new LocalAuth({ dataPath: this._opts.dataPath || './whatsapp' }),
+      puppeteer: { headless: true },
+    });
+    this._client.on('qr', (qr) => {
+      this._lastQr = qr;
+      this._qrState = 'shown';
+      qrt.default?.generate(qr, { small: true });
+    });
+    this._client.on('authenticated', () => { this._qrState = 'authenticated'; });
+    this._client.on('auth_failure', () => { this._qrState = 'failed'; });
+    this._client.on('message', async (msg) => {
+      try {
+        const reply = await this._processInbound({
+          threadId: msg.from, text: msg.body || '', gateInput: { token: msg.from },
+        });
+        if (reply) await msg.reply(reply);
+      } catch (e) {
+        if (e.code !== 'CHANNEL_GATED') {
+          process.stderr.write(`[whatsapp] inbound error: ${e.message}\n`);
+        }
+      }
+    });
+    await this._client.initialize();
+  }
+
+  async send(threadId, text) {
+    if (!this._client || this._qrState !== 'authenticated') {
+      const err = new Error('NOT_AUTHENTICATED');
+      err.code = 'NOT_AUTHENTICATED';
+      throw err;
+    }
+    await this._client.sendMessage(String(threadId), String(text));
+  }
+
+  async stop() {
+    if (this._client) { try { await this._client.destroy(); } catch { /* ignore */ } }
+    this._client = null;
+    await super.stop();
+  }
+}
+
+export function register({ addChannel }) {
+  addChannel('whatsapp', (opts) => new WhatsappChannel(opts));
+}

package/channels-whatsapp/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@lazyclaw/channel-whatsapp",
+  "version": "0.1.0",
+  "description": "WhatsApp channel plugin for lazyclaw v5 (whatsapp-web.js).",
+  "type": "module",
+  "main": "index.mjs",
+  "files": ["index.mjs"],
+  "peerDependencies": { "lazyclaw": ">=5.0.0" },
+  "dependencies": {
+    "whatsapp-web.js": "^1.23.0",
+    "qrcode-terminal": "^0.12.0"
+  }
+}

package/cli.mjs

@@ -311,27 +311,16 @@ async function main() {
     }
     case 'channels': {
       const sub = (rest.positional[0] || 'list').toLowerCase();
-      const { createLoader, listInstalled } = await import('./channels/loader.mjs');
-      const cfgDir = path.dirname(configPath());
-      const loader = createLoader({ configDir: cfgDir });
-      if (sub === 'install') {
-        const name = rest.positional[1];
-        if (!name) { process.stderr.write('usage: lazyclaw channels install <@lazyclaw/channel-name>\n'); process.exit(2); }
-        const info = await loader.install(name);
-        process.stdout.write(`installed ${info.name}@${info.version}\n`);
-        break;
-      }
-      if (sub === 'remove' || sub === 'uninstall') {
-        const name = rest.positional[1];
-        if (!name) { process.stderr.write('usage: lazyclaw channels remove <@lazyclaw/channel-name>\n'); process.exit(2); }
-        await loader.remove(name);
-        process.stdout.write(`removed ${name}\n`);
-        break;
-      }
-      // list
-      const rows = listInstalled(cfgDir);
-      if (!rows.length) { process.stdout.write('no channel plugins installed\n'); break; }
-      for (const r of rows) process.stdout.write(`${r.name}\t${r.version}\n`);
+      await (await import('./commands/channels.mjs')).cmdChannels(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'service': {
+      const sub = rest.positional[0];
+      await (await import('./commands/service.mjs')).cmdService(sub, rest.positional.slice(1), rest.flags);
+      break;
+    }
+    case 'gateway': {
+      await (await import('./commands/gateway.mjs')).cmdGateway(rest.flags);
       break;
     }
     case 'daemon': {