@voiceclaw/voiceclaw-plugin 1.1.0 → 1.1.2

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+interface PluginApi {
+    config: Record<string, any>;
+    logger: {
+        info: (msg: string) => void;
+        error: (msg: string) => void;
+        warn: (msg: string) => void;
+    };
+    registerChannel: (opts: {
+        plugin: any;
+    }) => void;
+}
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("zod").ZodObject<{
+        channels: import("zod").ZodOptional<import("zod").ZodObject<{
+            voiceclaw: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                pairingCode: import("zod").ZodOptional<import("zod").ZodString>;
+                workerUrl: import("zod").ZodOptional<import("zod").ZodString>;
+                enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                accounts: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+                    pairingCode: import("zod").ZodOptional<import("zod").ZodString>;
+                    workerUrl: import("zod").ZodOptional<import("zod").ZodString>;
+                    enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    register(api: PluginApi): void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,13 @@
+import { voiceClawPlugin, setLogger } from './src/channel.js';
+import { voiceClawConfigSchema } from './src/types.js';
+export default {
+    id: 'voiceclaw-plugin',
+    name: 'VoiceClaw',
+    description: 'VoiceClaw channel plugin — Siri & iOS/macOS voice entry for OpenClaw',
+    configSchema: voiceClawConfigSchema,
+    register(api) {
+        setLogger(api.logger);
+        api.registerChannel({ plugin: voiceClawPlugin });
+        api.logger.info('VoiceClaw channel plugin registered');
+    },
+};

package/dist/src/channel.d.ts

@@ -0,0 +1,62 @@
+import type { ResolvedAccount } from './types';
+interface Logger {
+    info: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+}
+export declare const voiceClawPlugin: {
+    id: string;
+    meta: {
+        id: string;
+        label: string;
+        selectionLabel: string;
+        docsPath: string;
+        blurb: string;
+        aliases: string[];
+    };
+    capabilities: {
+        chatTypes: string[];
+    };
+    configSchema: import("zod").ZodObject<{
+        channels: import("zod").ZodOptional<import("zod").ZodObject<{
+            voiceclaw: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                pairingCode: import("zod").ZodOptional<import("zod").ZodString>;
+                workerUrl: import("zod").ZodOptional<import("zod").ZodString>;
+                enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                accounts: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+                    pairingCode: import("zod").ZodOptional<import("zod").ZodString>;
+                    workerUrl: import("zod").ZodOptional<import("zod").ZodString>;
+                    enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    config: {
+        listAccountIds: (cfg: Record<string, any>) => string[];
+        resolveAccount: (cfg: Record<string, any>, accountId?: string) => ResolvedAccount | undefined;
+    };
+    outbound: {
+        deliveryMode: "direct";
+        sendText: (params: any) => Promise<{
+            ok: boolean;
+        }>;
+    };
+    gateway: {
+        startAccount: (ctx: any) => Promise<void>;
+        stopAccount: (ctx: any) => Promise<void>;
+    };
+    status: {
+        getStatus: (ctx: any) => Promise<{
+            ok: boolean;
+            label: string;
+            detail: {
+                accountId: string;
+                connected: string;
+            };
+        }>;
+    };
+};
+export declare function setLogger(logger: Logger): void;
+export declare function setInboundHandler(handler: (text: string, accountId: string) => Promise<void>): void;
+export {};

package/dist/src/channel.js

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+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) {
+    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');
+}
+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;
+}
+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;
+}
+// ── Channel plugin ─────────────────────────────────────────────
+const clients = new Map();
+let handleInbound = null;
+let pluginLogger = 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) => resolveAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveVoiceClawAccount(cfg, accountId),
+    },
+    outbound: {
+        deliveryMode: 'direct',
+        sendText: async (params) => {
+            const ctx = params.context;
+            const account = ctx?.account;
+            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) => {
+            const account = ctx.account;
+            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) => {
+                        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) => {
+            const account = ctx.account;
+            const client = clients.get(account.accountId);
+            if (client) {
+                client.stop();
+                clients.delete(account.accountId);
+                pluginLogger?.info(`VoiceClaw: Stopped "${account.accountId}"`);
+            }
+        },
+    },
+    status: {
+        getStatus: async (ctx) => {
+            const account = ctx.account;
+            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) {
+    pluginLogger = logger;
+}
+export function setInboundHandler(handler) {
+    handleInbound = handler;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+declare const voiceClawAccountSchema: z.ZodObject<{
+    pairingCode: z.ZodOptional<z.ZodString>;
+    workerUrl: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const voiceClawConfigSchema: z.ZodObject<{
+    channels: z.ZodOptional<z.ZodObject<{
+        voiceclaw: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            pairingCode: z.ZodOptional<z.ZodString>;
+            workerUrl: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            accounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+                pairingCode: z.ZodOptional<z.ZodString>;
+                workerUrl: z.ZodOptional<z.ZodString>;
+                enabled: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VoiceClawConfig = z.infer<typeof voiceClawConfigSchema>;
+export type ResolvedAccount = z.infer<typeof voiceClawAccountSchema> & {
+    accountId: string;
+};
+export declare function resolveAccountIds(cfg: VoiceClawConfig): string[];
+export declare function resolveVoiceClawAccount(cfg: VoiceClawConfig, accountId?: string): ResolvedAccount | undefined;
+export declare 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;
+export {};

package/dist/src/types.js

@@ -0,0 +1,46 @@
+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(),
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isMultiAccount(cfg) {
+    return cfg && typeof cfg === 'object' && 'accounts' in cfg;
+}
+export function resolveAccountIds(cfg) {
+    const vc = cfg.channels?.voiceclaw;
+    if (!vc)
+        return [];
+    if (isMultiAccount(vc))
+        return Object.keys(vc.accounts);
+    return ['default'];
+}
+export function resolveVoiceClawAccount(cfg, accountId) {
+    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';

package/dist/src/ws-client.d.ts

@@ -0,0 +1,46 @@
+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/src/ws-client.js

@@ -0,0 +1,146 @@
+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

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

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@voiceclaw/voiceclaw-plugin",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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",
   "files": [
-    "index.ts",
-    "src/"
+    "dist",
+    "openclaw.plugin.json",
+    "README.md"
   ],
   "openclaw": {
     "extensions": [
-      "./index.ts"
+      "dist/index.js"
     ],
     "channel": {
       "id": "voiceclaw",
@@ -57,6 +59,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
   }
 }

package/index.ts

@@ -1,26 +0,0 @@
-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/src/channel.ts

@@ -1,242 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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}`);
-  }
-}