@voiceclaw/voiceclaw-plugin 1.0.9 → 1.1.0

package/index.ts

@@ -0,0 +1,26 @@
+import { voiceClawPlugin, setLogger } from './src/channel.js';
+import { voiceClawConfigSchema } from './src/types.js';
+
+interface PluginApi {
+  config: Record<string, any>;
+  logger: {
+    info: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+  };
+  registerChannel: (opts: { plugin: any }) => void;
+}
+
+export default {
+  id: 'voiceclaw-plugin',
+  name: 'VoiceClaw',
+  description:
+    'VoiceClaw channel plugin — Siri & iOS/macOS voice entry for OpenClaw',
+  configSchema: voiceClawConfigSchema,
+  register(api: PluginApi) {
+    setLogger(api.logger);
+    api.registerChannel({ plugin: voiceClawPlugin });
+    api.logger.info('VoiceClaw channel plugin registered');
+  },
+};
+

package/package.json

@@ -1,33 +1,16 @@
 {
   "name": "@voiceclaw/voiceclaw-plugin",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "OpenClaw channel plugin for VoiceClaw — relay messages between your AI agent and the VoiceClaw iOS/macOS app via Siri",
-  "main": "dist/index.js",
   "type": "module",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/anthropics/voiceclaw"
-  },
-  "homepage": "https://voiceclaw.techartisan.site",
-  "keywords": [
-    "openclaw",
-    "openclaw-plugin",
-    "openclaw-channel",
-    "siri",
-    "voiceclaw",
-    "ios",
-    "macos",
-    "voice"
-  ],
   "files": [
-    "dist",
-    "openclaw.plugin.json",
-    "README.md"
+    "index.ts",
+    "src/"
   ],
   "openclaw": {
     "extensions": [
-      "dist/index.js"
+      "./index.ts"
     ],
     "channel": {
       "id": "voiceclaw",
@@ -41,22 +24,39 @@
       ]
     },
     "install": {
-      "npmSpec": "@voiceclaw/voiceclaw-plugin",
-      "defaultChoice": "npm"
+      "npmSpec": "@voiceclaw/voiceclaw-plugin"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/voiceclaw"
+  },
+  "homepage": "https://voiceclaw.techartisan.site",
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "openclaw-channel",
+    "siri",
+    "voiceclaw",
+    "ios",
+    "macos",
+    "voice"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.1.0"
+  },
+  "dependencies": {
+    "ws": "^8.18.0",
+    "zod": "^3.24.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/ws": "^8.18.1",
     "typescript": "^5.7.0"
   },
-  "dependencies": {
-    "ws": "^8.18.0"
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/channel.ts

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import type { ResolvedAccount, UserMessage } from './types';
+import {
+  DEFAULT_WORKER_URL,
+  resolveAccountIds,
+  resolveVoiceClawAccount,
+  voiceClawConfigSchema,
+} from './types';
+import { RelayWsClient } from './ws-client';
+
+// ── Token persistence ──────────────────────────────────────────
+
+const DATA_DIR = join(homedir(), '.voiceclaw');
+
+function tokenPath(accountId: string): string {
+  return join(DATA_DIR, `session-${accountId}.token`);
+}
+
+function loadSavedToken(accountId: string): string | null {
+  const p = tokenPath(accountId);
+  if (existsSync(p)) {
+    const token = readFileSync(p, 'utf-8').trim();
+    if (token.length > 0) return token;
+  }
+  return null;
+}
+
+function saveToken(accountId: string, token: string): void {
+  if (!existsSync(DATA_DIR)) {
+    mkdirSync(DATA_DIR, { recursive: true });
+  }
+  writeFileSync(tokenPath(accountId), token, 'utf-8');
+}
+
+// ── Pairing code exchange ──────────────────────────────────────
+
+interface Logger {
+  info: (msg: string) => void;
+  error: (msg: string) => void;
+  warn: (msg: string) => void;
+}
+
+async function exchangePairingCode(
+  code: string,
+  workerUrl: string,
+  logger: Logger,
+): Promise<string> {
+  logger.info('VoiceClaw: Exchanging pairing code for session token...');
+  const url = `${workerUrl}/pair?code=${encodeURIComponent(code)}`;
+  const resp = await fetch(url, { method: 'POST' });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Pairing failed (${resp.status}): ${body}`);
+  }
+
+  const data = (await resp.json()) as { sessionToken?: string };
+  if (!data.sessionToken) {
+    throw new Error('Pairing response missing sessionToken');
+  }
+
+  logger.info('VoiceClaw: Pairing successful, session token saved');
+  return data.sessionToken;
+}
+
+async function resolveToken(
+  accountId: string,
+  account: ResolvedAccount,
+  logger: Logger,
+): Promise<string> {
+  const saved = loadSavedToken(accountId);
+  if (saved) {
+    logger.info(`VoiceClaw: Using saved session token for "${accountId}"`);
+    return saved;
+  }
+
+  if (!account.pairingCode) {
+    throw new Error(
+      `No pairing code configured for "${accountId}" and no saved session token found`,
+    );
+  }
+
+  const workerUrl = account.workerUrl ?? DEFAULT_WORKER_URL;
+  const sessionToken = await exchangePairingCode(
+    account.pairingCode,
+    workerUrl,
+    logger,
+  );
+
+  saveToken(accountId, sessionToken);
+  return sessionToken;
+}
+
+// ── Channel plugin ─────────────────────────────────────────────
+
+const clients = new Map<string, RelayWsClient>();
+let handleInbound: ((text: string, accountId: string) => Promise<void>) | null =
+  null;
+let pluginLogger: Logger | null = null;
+
+export const voiceClawPlugin = {
+  id: 'voiceclaw',
+
+  meta: {
+    id: 'voiceclaw',
+    label: 'VoiceClaw',
+    selectionLabel: 'VoiceClaw (Siri / iOS / macOS)',
+    docsPath: '/channels/voiceclaw',
+    blurb:
+      'Voice entry for OpenClaw via Siri & native iOS/macOS app.',
+    aliases: ['vc', 'siri'],
+  },
+
+  capabilities: { chatTypes: ['direct'] },
+
+  configSchema: voiceClawConfigSchema,
+
+  config: {
+    listAccountIds: (cfg: Record<string, any>): string[] =>
+      resolveAccountIds(cfg as any),
+    resolveAccount: (cfg: Record<string, any>, accountId?: string) =>
+      resolveVoiceClawAccount(cfg as any, accountId),
+  },
+
+  outbound: {
+    deliveryMode: 'direct' as const,
+
+    sendText: async (params: any) => {
+      const ctx = params.context;
+      const account = ctx?.account as ResolvedAccount | undefined;
+      const accountId = account?.accountId ?? 'default';
+      const client = clients.get(accountId);
+
+      if (!client || client.connectionState !== 'connected') {
+        pluginLogger?.warn(
+          `VoiceClaw: No connection for "${accountId}", reply dropped`,
+        );
+        return { ok: false };
+      }
+
+      client.send({
+        type: 'agent_reply',
+        id: crypto.randomUUID(),
+        replyTo: '',
+        text: params.text ?? '',
+        ts: new Date().toISOString(),
+      });
+
+      return { ok: true };
+    },
+  },
+
+  gateway: {
+    startAccount: async (ctx: any) => {
+      const account = ctx.account as ResolvedAccount;
+      const logger = pluginLogger!;
+
+      logger.info(`VoiceClaw: Starting account "${account.accountId}"...`);
+
+      try {
+        const sessionToken = await resolveToken(
+          account.accountId,
+          account,
+          logger,
+        );
+        const workerUrl = account.workerUrl ?? DEFAULT_WORKER_URL;
+
+        const client = new RelayWsClient({
+          token: sessionToken,
+          workerUrl,
+          onUserMessage: (msg: UserMessage) => {
+            logger.info(
+              `VoiceClaw: User message (${msg.id}): ${msg.text.slice(0, 50)}...`,
+            );
+            handleInbound?.(msg.text, account.accountId);
+          },
+          onStateChange: (state) => {
+            logger.info(`VoiceClaw: [${account.accountId}] ${state}`);
+          },
+          logger,
+        });
+
+        client.start();
+        clients.set(account.accountId, client);
+        ctx.setStatus?.({
+          ok: true,
+          label: `VoiceClaw (${account.accountId})`,
+        });
+        logger.info(
+          `VoiceClaw: Started relay for "${account.accountId}"`,
+        );
+      } catch (err) {
+        logger.error(
+          `VoiceClaw: Failed to start "${account.accountId}": ${err}`,
+        );
+        ctx.setStatus?.({
+          ok: false,
+          label: `VoiceClaw error: ${err}`,
+        });
+      }
+    },
+
+    stopAccount: async (ctx: any) => {
+      const account = ctx.account as ResolvedAccount;
+      const client = clients.get(account.accountId);
+      if (client) {
+        client.stop();
+        clients.delete(account.accountId);
+        pluginLogger?.info(`VoiceClaw: Stopped "${account.accountId}"`);
+      }
+    },
+  },
+
+  status: {
+    getStatus: async (ctx: any) => {
+      const account = ctx.account as ResolvedAccount;
+      const client = clients.get(account.accountId);
+      return {
+        ok: client?.connectionState === 'connected',
+        label: `VoiceClaw (${account.accountId})`,
+        detail: {
+          accountId: account.accountId,
+          connected: client?.connectionState ?? 'not started',
+        },
+      };
+    },
+  },
+};
+
+// ── Plugin entry point (object form) ───────────────────────────
+
+export function setLogger(logger: Logger) {
+  pluginLogger = logger;
+}
+
+export function setInboundHandler(
+  handler: (text: string, accountId: string) => Promise<void>,
+) {
+  handleInbound = handler;
+}

package/src/types.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+
+// ── Account schema ─────────────────────────────────────────────
+
+const voiceClawAccountSchema = z.object({
+  pairingCode: z.string().min(1).optional(),
+  workerUrl: z.string().url().optional(),
+  enabled: z.boolean().optional(),
+});
+
+const voiceClawMultiAccountSchema = z.object({
+  accounts: z.record(z.string(), voiceClawAccountSchema),
+});
+
+export const voiceClawConfigSchema = z.object({
+  channels: z
+    .object({
+      voiceclaw: z
+        .union([voiceClawAccountSchema, voiceClawMultiAccountSchema])
+        .optional(),
+    })
+    .optional(),
+});
+
+export type VoiceClawConfig = z.infer<typeof voiceClawConfigSchema>;
+
+export type ResolvedAccount = z.infer<typeof voiceClawAccountSchema> & {
+  accountId: string;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isMultiAccount(cfg: any): cfg is z.infer<typeof voiceClawMultiAccountSchema> {
+  return cfg && typeof cfg === 'object' && 'accounts' in cfg;
+}
+
+export function resolveAccountIds(cfg: VoiceClawConfig): string[] {
+  const vc = cfg.channels?.voiceclaw;
+  if (!vc) return [];
+  if (isMultiAccount(vc)) return Object.keys(vc.accounts);
+  return ['default'];
+}
+
+export function resolveVoiceClawAccount(
+  cfg: VoiceClawConfig,
+  accountId?: string,
+): ResolvedAccount | undefined {
+  const vc = cfg.channels?.voiceclaw;
+  if (!vc) return undefined;
+
+  if ('accounts' in vc) {
+    const id = accountId ?? Object.keys(vc.accounts)[0];
+    const acc = vc.accounts[id];
+    if (!acc) return undefined;
+    return { ...acc, accountId: id };
+  }
+
+  return { ...vc, accountId: accountId ?? 'default' };
+}
+
+// ── Message protocol types ─────────────────────────────────────
+
+export const DEFAULT_WORKER_URL = 'https://voiceclaw-api.techartisan.site';
+
+export interface UserMessage {
+  type: 'user_message';
+  id: string;
+  text: string;
+  ts: string;
+}
+
+export interface AgentReplyMessage {
+  type: 'agent_reply';
+  id: string;
+  replyTo: string;
+  text: string;
+  ts: string;
+}
+
+export interface PingMessage {
+  type: 'ping';
+}
+export interface PongMessage {
+  type: 'pong';
+}
+
+export interface AuthOkMessage {
+  type: 'auth_ok';
+}
+export interface AuthErrorMessage {
+  type: 'auth_error';
+  reason: string;
+}
+
+export type InboundRelayMessage =
+  | AuthOkMessage
+  | AuthErrorMessage
+  | UserMessage
+  | PongMessage;
+
+export type OutboundRelayMessage = AgentReplyMessage | PingMessage;

package/src/ws-client.ts

@@ -0,0 +1,185 @@
+import WebSocket from 'ws';
+import type {
+  InboundRelayMessage,
+  OutboundRelayMessage,
+  UserMessage,
+} from './types';
+import { DEFAULT_WORKER_URL } from './types';
+
+export type WsClientState = 'disconnected' | 'connecting' | 'connected';
+
+export interface WsClientOptions {
+  token: string;
+  workerUrl?: string;
+  onUserMessage: (msg: UserMessage) => void;
+  onStateChange?: (state: WsClientState) => void;
+  logger?: { info: (msg: string) => void; error: (msg: string) => void };
+}
+
+/**
+ * Persistent WebSocket client that connects to the Cloudflare Workers
+ * relay as the "plugin" role. Auth is implicit (the token is the room
+ * key). Handles heartbeat and automatic reconnection with exponential
+ * backoff.
+ */
+export class RelayWsClient {
+  private ws: WebSocket | null = null;
+  private opts: WsClientOptions;
+  private state: WsClientState = 'disconnected';
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private backoffMs = 1000;
+  private stopped = false;
+
+  private static readonly MAX_BACKOFF_MS = 30_000;
+  private static readonly HEARTBEAT_MS = 30_000;
+
+  constructor(opts: WsClientOptions) {
+    this.opts = opts;
+  }
+
+  /** Start the WebSocket connection. */
+  start(): void {
+    this.stopped = false;
+    this.connect();
+  }
+
+  /** Stop and close the WebSocket; no reconnect. */
+  stop(): void {
+    this.stopped = true;
+    this.cleanup();
+    this.setState('disconnected');
+  }
+
+  /** Send a message to the relay. */
+  send(msg: OutboundRelayMessage): void {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
+  /** Current connection state. */
+  get connectionState(): WsClientState {
+    return this.state;
+  }
+
+  // ── Private ──────────────────────────────────────────────────
+
+  private connect(): void {
+    if (this.stopped) return;
+    this.cleanup();
+    this.setState('connecting');
+
+    const base = (this.opts.workerUrl ?? DEFAULT_WORKER_URL).replace(/\/$/, '');
+    const wsUrl = base
+      .replace(/^https:\/\//, 'wss://')
+      .replace(/^http:\/\//, 'ws://');
+    const url = `${wsUrl}/ws?token=${encodeURIComponent(this.opts.token)}&role=plugin`;
+
+    this.log('info', `Connecting to relay...`);
+    const ws = new WebSocket(url);
+
+    ws.on('open', () => {
+      this.log('info', 'WebSocket open');
+    });
+
+    ws.on('message', (data: WebSocket.Data) => {
+      try {
+        const raw = typeof data === 'string' ? data : data.toString();
+        const msg: InboundRelayMessage = JSON.parse(raw);
+        this.handleMessage(msg);
+      } catch {
+        this.log('error', `Failed to parse message: ${data}`);
+      }
+    });
+
+    ws.on('close', () => {
+      this.log('info', 'WebSocket closed');
+      this.setState('disconnected');
+      this.scheduleReconnect();
+    });
+
+    ws.on('error', (err: Error) => {
+      this.log('error', `WebSocket error: ${err.message}`);
+    });
+
+    this.ws = ws;
+  }
+
+  private handleMessage(msg: InboundRelayMessage): void {
+    switch (msg.type) {
+      case 'auth_ok':
+        this.log('info', 'Connected and authenticated');
+        this.setState('connected');
+        this.backoffMs = 1000;
+        this.startHeartbeat();
+        break;
+
+      case 'auth_error':
+        this.log('error', `Auth failed: ${msg.reason}`);
+        this.setState('disconnected');
+        this.stopped = true;
+        break;
+
+      case 'user_message':
+        this.opts.onUserMessage(msg);
+        break;
+
+      case 'pong':
+        break;
+    }
+  }
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: 'ping' }));
+      }
+    }, RelayWsClient.HEARTBEAT_MS);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  private scheduleReconnect(): void {
+    if (this.stopped) return;
+    this.log('info', `Reconnecting in ${this.backoffMs}ms...`);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, this.backoffMs);
+    this.backoffMs = Math.min(this.backoffMs * 2, RelayWsClient.MAX_BACKOFF_MS);
+  }
+
+  private cleanup(): void {
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      if (
+        this.ws.readyState === WebSocket.OPEN ||
+        this.ws.readyState === WebSocket.CONNECTING
+      ) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+  }
+
+  private setState(s: WsClientState): void {
+    if (this.state === s) return;
+    this.state = s;
+    this.opts.onStateChange?.(s);
+  }
+
+  private log(level: 'info' | 'error', msg: string): void {
+    this.opts.logger?.[level](`[VoiceClaw WS] ${msg}`);
+  }
+}

package/dist/index.d.ts

@@ -1,13 +0,0 @@
-interface PluginApi {
-    config: Record<string, any>;
-    logger: {
-        info: (msg: string) => void;
-        error: (msg: string) => void;
-        warn: (msg: string) => void;
-    };
-    registerChannel: (opts: {
-        plugin: any;
-    }) => void;
-}
-export default function register(api: PluginApi): void;
-export {};

package/dist/index.js

@@ -1,172 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { RelayWsClient } from './ws-client';
-import { DEFAULT_WORKER_URL } from './types';
-const clients = new Map();
-let handleInbound = null;
-// ── Token persistence ──────────────────────────────────────────
-const DATA_DIR = join(homedir(), '.voiceclaw');
-function tokenPath(accountId) {
-    return join(DATA_DIR, `session-${accountId}.token`);
-}
-function loadSavedToken(accountId) {
-    const p = tokenPath(accountId);
-    if (existsSync(p)) {
-        const token = readFileSync(p, 'utf-8').trim();
-        if (token.length > 0)
-            return token;
-    }
-    return null;
-}
-function saveToken(accountId, token) {
-    if (!existsSync(DATA_DIR)) {
-        mkdirSync(DATA_DIR, { recursive: true });
-    }
-    writeFileSync(tokenPath(accountId), token, 'utf-8');
-}
-// ── Pairing code exchange ──────────────────────────────────────
-async function exchangePairingCode(code, workerUrl, logger) {
-    logger.info(`VoiceClaw: Exchanging pairing code for session token...`);
-    const url = `${workerUrl}/pair?code=${encodeURIComponent(code)}`;
-    const resp = await fetch(url, { method: 'POST' });
-    if (!resp.ok) {
-        const body = await resp.text();
-        throw new Error(`Pairing failed (${resp.status}): ${body}`);
-    }
-    const data = (await resp.json());
-    if (!data.sessionToken) {
-        throw new Error('Pairing response missing sessionToken');
-    }
-    logger.info('VoiceClaw: Pairing successful, session token saved');
-    return data.sessionToken;
-}
-/**
- * Resolve the session token for an account:
- * 1. If a saved session token exists on disk, use it.
- * 2. Otherwise, exchange the pairing code and save the result.
- */
-async function resolveToken(accountId, account, logger) {
-    const saved = loadSavedToken(accountId);
-    if (saved) {
-        logger.info(`VoiceClaw: Using saved session token for "${accountId}"`);
-        return saved;
-    }
-    if (!account.pairingCode) {
-        throw new Error(`No pairing code configured for "${accountId}" and no saved session token found`);
-    }
-    const workerUrl = account.workerUrl ?? DEFAULT_WORKER_URL;
-    const sessionToken = await exchangePairingCode(account.pairingCode, workerUrl, logger);
-    saveToken(accountId, sessionToken);
-    return sessionToken;
-}
-// ── Plugin registration ────────────────────────────────────────
-export default function register(api) {
-    const channelId = 'voiceclaw';
-    const voiceClawChannel = {
-        id: channelId,
-        meta: {
-            id: channelId,
-            label: 'VoiceClaw',
-            selectionLabel: 'VoiceClaw (Siri / iOS / macOS)',
-            docsPath: '/channels/voiceclaw',
-            blurb: 'Voice entry for OpenClaw via Siri & native iOS/macOS app.',
-            aliases: ['vc', 'siri'],
-        },
-        capabilities: { chatTypes: ['direct'] },
-        config: {
-            listAccountIds: (cfg) => Object.keys(cfg.channels?.voiceclaw?.accounts ?? {}),
-            resolveAccount: (cfg, accountId) => cfg.channels?.voiceclaw?.accounts?.[accountId ?? 'default'] ?? {
-                accountId,
-            },
-        },
-        outbound: {
-            deliveryMode: 'direct',
-            sendText: async ({ text, accountId, }) => {
-                const id = accountId ?? 'default';
-                const client = clients.get(id);
-                if (!client || client.connectionState !== 'connected') {
-                    api.logger.warn(`VoiceClaw: No connection for "${id}", reply dropped`);
-                    return { ok: false };
-                }
-                client.send({
-                    type: 'agent_reply',
-                    id: crypto.randomUUID(),
-                    replyTo: '',
-                    text,
-                    ts: new Date().toISOString(),
-                });
-                return { ok: true };
-            },
-        },
-        onboarding: {
-            configure: async (ctx) => {
-                // Support: openclaw channels add --channel voiceclaw --token <code>
-                let pairingCode = ctx.options?.token;
-                if (!pairingCode) {
-                    pairingCode = await ctx.prompter.text({
-                        message: 'Enter the 6-digit pairing code from the VoiceClaw app:',
-                        validate: (v) => v.trim().length >= 4 ? undefined : 'Pairing code must be at least 4 characters',
-                    });
-                }
-                if (!pairingCode || pairingCode.trim() === '') {
-                    return 'skip';
-                }
-                const cfg = { ...ctx.config };
-                if (!cfg.channels)
-                    cfg.channels = {};
-                if (!cfg.channels.voiceclaw)
-                    cfg.channels.voiceclaw = {};
-                if (!cfg.channels.voiceclaw.accounts)
-                    cfg.channels.voiceclaw.accounts = {};
-                cfg.channels.voiceclaw.accounts.default = {
-                    pairingCode: pairingCode.trim(),
-                };
-                return { cfg, accountId: 'default' };
-            },
-        },
-        gateway: {
-            start: async (ctx) => {
-                api.logger.info('VoiceClaw: gateway.start() called');
-                handleInbound = ctx.processInbound;
-                const accounts = ctx.config.channels?.voiceclaw?.accounts ?? {};
-                for (const [accountId, account] of Object.entries(accounts)) {
-                    if (account.enabled === false)
-                        continue;
-                    try {
-                        const sessionToken = await resolveToken(accountId, account, api.logger);
-                        const workerUrl = account.workerUrl ?? DEFAULT_WORKER_URL;
-                        const client = new RelayWsClient({
-                            token: sessionToken,
-                            workerUrl,
-                            onUserMessage: (msg) => {
-                                api.logger.info(`VoiceClaw: User message (${msg.id}): ${msg.text.slice(0, 50)}...`);
-                                handleInbound?.(msg.text, accountId);
-                            },
-                            onStateChange: (state) => {
-                                api.logger.info(`VoiceClaw: [${accountId}] ${state}`);
-                            },
-                            logger: api.logger,
-                        });
-                        client.start();
-                        clients.set(accountId, client);
-                        api.logger.info(`VoiceClaw: Started relay for "${accountId}"`);
-                    }
-                    catch (err) {
-                        api.logger.error(`VoiceClaw: Failed to start "${accountId}": ${err}`);
-                    }
-                }
-            },
-            stop: () => {
-                for (const [accountId, client] of clients) {
-                    client.stop();
-                    api.logger.info(`VoiceClaw: Stopped "${accountId}"`);
-                }
-                clients.clear();
-                handleInbound = null;
-            },
-        },
-    };
-    api.registerChannel({ plugin: voiceClawChannel });
-    api.logger.info('VoiceClaw channel plugin registered');
-}

package/dist/types.d.ts

@@ -1,45 +0,0 @@
-/** Role of the WebSocket client. */
-export type ClientRole = 'app' | 'plugin';
-/** Auth success (sent by server on connect). */
-export interface AuthOkMessage {
-    type: 'auth_ok';
-}
-/** Auth failure. */
-export interface AuthErrorMessage {
-    type: 'auth_error';
-    reason: string;
-}
-/** User message from app → plugin. */
-export interface UserMessage {
-    type: 'user_message';
-    id: string;
-    text: string;
-    ts: string;
-}
-/** Agent reply from plugin → app. */
-export interface AgentReplyMessage {
-    type: 'agent_reply';
-    id: string;
-    replyTo: string;
-    text: string;
-    ts: string;
-}
-/** Heartbeat. */
-export interface PingMessage {
-    type: 'ping';
-}
-export interface PongMessage {
-    type: 'pong';
-}
-/** Plugin config from channels.voiceclaw.accounts.<id> */
-export interface VoiceClawAccountConfig {
-    pairingCode: string;
-    workerUrl?: string;
-    enabled?: boolean;
-}
-/** Default relay server URL. */
-export declare const DEFAULT_WORKER_URL = "https://voiceclaw-api.techartisan.site";
-/** Messages the plugin receives from the relay. */
-export type InboundRelayMessage = AuthOkMessage | AuthErrorMessage | UserMessage | PongMessage;
-/** Messages the plugin sends to the relay. */
-export type OutboundRelayMessage = AgentReplyMessage | PingMessage;

package/dist/types.js

@@ -1,4 +0,0 @@
-// ── Shared message protocol types ──────────────────────────────
-// Mirrors workers/src/protocol.ts for the plugin side.
-/** Default relay server URL. */
-export const DEFAULT_WORKER_URL = 'https://voiceclaw-api.techartisan.site';

package/dist/ws-client.d.ts

@@ -1,46 +0,0 @@
-import type { OutboundRelayMessage, UserMessage } from './types';
-export type WsClientState = 'disconnected' | 'connecting' | 'connected';
-export interface WsClientOptions {
-    token: string;
-    workerUrl?: string;
-    onUserMessage: (msg: UserMessage) => void;
-    onStateChange?: (state: WsClientState) => void;
-    logger?: {
-        info: (msg: string) => void;
-        error: (msg: string) => void;
-    };
-}
-/**
- * Persistent WebSocket client that connects to the Cloudflare Workers
- * relay as the "plugin" role. Auth is implicit (the token is the room
- * key). Handles heartbeat and automatic reconnection with exponential
- * backoff.
- */
-export declare class RelayWsClient {
-    private ws;
-    private opts;
-    private state;
-    private reconnectTimer;
-    private heartbeatTimer;
-    private backoffMs;
-    private stopped;
-    private static readonly MAX_BACKOFF_MS;
-    private static readonly HEARTBEAT_MS;
-    constructor(opts: WsClientOptions);
-    /** Start the WebSocket connection. */
-    start(): void;
-    /** Stop and close the WebSocket; no reconnect. */
-    stop(): void;
-    /** Send a message to the relay. */
-    send(msg: OutboundRelayMessage): void;
-    /** Current connection state. */
-    get connectionState(): WsClientState;
-    private connect;
-    private handleMessage;
-    private startHeartbeat;
-    private stopHeartbeat;
-    private scheduleReconnect;
-    private cleanup;
-    private setState;
-    private log;
-}

package/dist/ws-client.js

@@ -1,146 +0,0 @@
-import WebSocket from 'ws';
-import { DEFAULT_WORKER_URL } from './types';
-/**
- * Persistent WebSocket client that connects to the Cloudflare Workers
- * relay as the "plugin" role. Auth is implicit (the token is the room
- * key). Handles heartbeat and automatic reconnection with exponential
- * backoff.
- */
-export class RelayWsClient {
-    ws = null;
-    opts;
-    state = 'disconnected';
-    reconnectTimer = null;
-    heartbeatTimer = null;
-    backoffMs = 1000;
-    stopped = false;
-    static MAX_BACKOFF_MS = 30_000;
-    static HEARTBEAT_MS = 30_000;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    /** Start the WebSocket connection. */
-    start() {
-        this.stopped = false;
-        this.connect();
-    }
-    /** Stop and close the WebSocket; no reconnect. */
-    stop() {
-        this.stopped = true;
-        this.cleanup();
-        this.setState('disconnected');
-    }
-    /** Send a message to the relay. */
-    send(msg) {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify(msg));
-        }
-    }
-    /** Current connection state. */
-    get connectionState() {
-        return this.state;
-    }
-    // ── Private ──────────────────────────────────────────────────
-    connect() {
-        if (this.stopped)
-            return;
-        this.cleanup();
-        this.setState('connecting');
-        const base = (this.opts.workerUrl ?? DEFAULT_WORKER_URL).replace(/\/$/, '');
-        const wsUrl = base
-            .replace(/^https:\/\//, 'wss://')
-            .replace(/^http:\/\//, 'ws://');
-        const url = `${wsUrl}/ws?token=${encodeURIComponent(this.opts.token)}&role=plugin`;
-        this.log('info', `Connecting to relay...`);
-        const ws = new WebSocket(url);
-        ws.on('open', () => {
-            this.log('info', 'WebSocket open');
-        });
-        ws.on('message', (data) => {
-            try {
-                const raw = typeof data === 'string' ? data : data.toString();
-                const msg = JSON.parse(raw);
-                this.handleMessage(msg);
-            }
-            catch {
-                this.log('error', `Failed to parse message: ${data}`);
-            }
-        });
-        ws.on('close', () => {
-            this.log('info', 'WebSocket closed');
-            this.setState('disconnected');
-            this.scheduleReconnect();
-        });
-        ws.on('error', (err) => {
-            this.log('error', `WebSocket error: ${err.message}`);
-        });
-        this.ws = ws;
-    }
-    handleMessage(msg) {
-        switch (msg.type) {
-            case 'auth_ok':
-                this.log('info', 'Connected and authenticated');
-                this.setState('connected');
-                this.backoffMs = 1000;
-                this.startHeartbeat();
-                break;
-            case 'auth_error':
-                this.log('error', `Auth failed: ${msg.reason}`);
-                this.setState('disconnected');
-                this.stopped = true;
-                break;
-            case 'user_message':
-                this.opts.onUserMessage(msg);
-                break;
-            case 'pong':
-                break;
-        }
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatTimer = setInterval(() => {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.send(JSON.stringify({ type: 'ping' }));
-            }
-        }, RelayWsClient.HEARTBEAT_MS);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-    }
-    scheduleReconnect() {
-        if (this.stopped)
-            return;
-        this.log('info', `Reconnecting in ${this.backoffMs}ms...`);
-        this.reconnectTimer = setTimeout(() => {
-            this.connect();
-        }, this.backoffMs);
-        this.backoffMs = Math.min(this.backoffMs * 2, RelayWsClient.MAX_BACKOFF_MS);
-    }
-    cleanup() {
-        this.stopHeartbeat();
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        if (this.ws) {
-            this.ws.removeAllListeners();
-            if (this.ws.readyState === WebSocket.OPEN ||
-                this.ws.readyState === WebSocket.CONNECTING) {
-                this.ws.close();
-            }
-            this.ws = null;
-        }
-    }
-    setState(s) {
-        if (this.state === s)
-            return;
-        this.state = s;
-        this.opts.onStateChange?.(s);
-    }
-    log(level, msg) {
-        this.opts.logger?.[level](`[VoiceClaw WS] ${msg}`);
-    }
-}

package/openclaw.plugin.json

@@ -1,11 +0,0 @@
-{
-  "id": "voiceclaw-plugin",
-  "name": "VoiceClaw",
-  "version": "1.0.0",
-  "description": "VoiceClaw channel plugin — Siri & iOS/macOS voice entry for OpenClaw",
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {}
-  }
-}