@voiceclaw/voiceclaw-plugin 1.1.6 → 1.1.9

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 interface PluginApi {
     config: Record<string, any>;
+    runtime: any;
     logger: {
         info: (msg: string) => void;
         error: (msg: string) => void;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { voiceClawPlugin, setLogger } from './src/channel.js';
+import { voiceClawPlugin, setLogger, setRuntime, setConfig } from './src/channel.js';
 import { voiceClawConfigSchema } from './src/types.js';
 export default {
     id: 'voiceclaw-plugin',
@@ -7,6 +7,8 @@ export default {
     configSchema: voiceClawConfigSchema,
     register(api) {
         setLogger(api.logger);
+        setRuntime(api.runtime);
+        setConfig(api.config);
         api.registerChannel({ plugin: voiceClawPlugin });
         api.logger.info('VoiceClaw channel plugin registered');
     },

package/dist/src/channel.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedAccount } from './types';
+import type { ResolvedAccount } from './types.js';
 interface Logger {
     info: (msg: string) => void;
     error: (msg: string) => void;
@@ -35,6 +35,28 @@ export declare const voiceClawPlugin: {
     config: {
         listAccountIds: (cfg: Record<string, any>) => string[];
         resolveAccount: (cfg: Record<string, any>, accountId?: string) => ResolvedAccount | undefined;
+        isConfigured: (account: ResolvedAccount) => Promise<boolean>;
+        unconfiguredReason: () => string;
+        isEnabled: (account: ResolvedAccount) => boolean;
+        disabledReason: () => string;
+        describeAccount: (account: ResolvedAccount) => {
+            accountId: string;
+            enabled: boolean;
+            configured: boolean;
+        };
+        setAccountEnabled: ({ cfg, accountId, enabled }: any) => any;
+        deleteAccount: ({ cfg, accountId }: any) => any;
+    };
+    setup: {
+        resolveAccountId: ({ accountId }: any) => any;
+        applyAccountName: ({ cfg, accountId, name }: any) => any;
+        applyAccountConfig: ({ cfg, accountId, input }: any) => any;
+    };
+    onboarding: {
+        configure: (ctx: any) => Promise<"skip" | {
+            cfg: any;
+            accountId: string;
+        }>;
     };
     outbound: {
         deliveryMode: "direct";
@@ -42,11 +64,31 @@ export declare const voiceClawPlugin: {
             ok: boolean;
         }>;
     };
-    onboarding: {
-        configure: (ctx: any) => Promise<"skip" | {
-            cfg: any;
+    status: {
+        defaultRuntime: {
             accountId: string;
+            running: boolean;
+            connected: boolean;
+            lastMessageAt: null;
+            lastError: null;
+        };
+        buildChannelSummary: ({ account, snapshot }: any) => Promise<{
+            configured: boolean;
+            running: any;
+            connected: any;
+            lastMessageAt: any;
+            lastError: any;
+        }>;
+        buildAccountSnapshot: ({ account, runtime }: any) => Promise<{
+            accountId: any;
+            enabled: boolean;
+            configured: boolean;
+            running: any;
+            connected: any;
+            lastMessageAt: any;
+            lastError: any;
         }>;
+        resolveAccountState: ({ configured }: any) => "paired" | "not paired";
     };
     gateway: {
         startAccount: (ctx: any) => Promise<void>;
@@ -54,5 +96,6 @@ export declare const voiceClawPlugin: {
     };
 };
 export declare function setLogger(logger: Logger): void;
-export declare function setInboundHandler(handler: (text: string, accountId: string) => Promise<void>): void;
+export declare function setRuntime(runtime: any): void;
+export declare function setConfig(config: any): void;
 export {};

package/dist/src/channel.js

@@ -1,8 +1,8 @@
 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';
+import { DEFAULT_WORKER_URL, resolveAccountIds, resolveVoiceClawAccount, voiceClawConfigSchema, } from './types.js';
+import { RelayWsClient } from './ws-client.js';
 // ── Token persistence ──────────────────────────────────────────
 const DATA_DIR = join(homedir(), '.voiceclaw');
 function tokenPath(accountId) {
@@ -54,8 +54,11 @@ async function resolveToken(accountId, account, logger) {
 }
 // ── Channel plugin ─────────────────────────────────────────────
 const clients = new Map();
-let handleInbound = null;
 let pluginLogger = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let pluginRuntime = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let pluginConfig = null;
 export const voiceClawPlugin = {
     id: 'voiceclaw',
     meta: {
@@ -71,39 +74,99 @@ export const voiceClawPlugin = {
     config: {
         listAccountIds: (cfg) => resolveAccountIds(cfg),
         resolveAccount: (cfg, accountId) => resolveVoiceClawAccount(cfg, accountId),
+        isConfigured: async (account) => {
+            // Configured if there's a saved token or a pairing code
+            return loadSavedToken(account.accountId) !== null || Boolean(account.pairingCode);
+        },
+        unconfiguredReason: () => 'no pairing code',
+        isEnabled: (account) => account.enabled !== false,
+        disabledReason: () => 'disabled',
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled !== false,
+            configured: loadSavedToken(account.accountId) !== null || Boolean(account.pairingCode),
+        }),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => {
+            const accounts = { ...cfg.channels?.voiceclaw?.accounts };
+            const existing = accounts[accountId] ?? {};
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    voiceclaw: {
+                        ...cfg.channels?.voiceclaw,
+                        accounts: {
+                            ...accounts,
+                            [accountId]: { ...existing, enabled },
+                        },
+                    },
+                },
+            };
+        },
+        deleteAccount: ({ cfg, accountId }) => {
+            const accounts = { ...cfg.channels?.voiceclaw?.accounts };
+            delete accounts[accountId];
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    voiceclaw: {
+                        ...cfg.channels?.voiceclaw,
+                        accounts: Object.keys(accounts).length ? accounts : undefined,
+                    },
+                },
+            };
+        },
     },
-    outbound: {
-        deliveryMode: 'direct',
-        sendText: async (params) => {
-            pluginLogger?.info(`VoiceClaw sendText called, keys: ${JSON.stringify(Object.keys(params))}`);
-            const ctx = params.context;
-            const account = ctx?.account;
-            const accountId = account?.accountId ?? params.accountId ?? 'default';
-            const text = params.text ?? '';
-            pluginLogger?.info(`VoiceClaw sendText: accountId="${accountId}", text="${text.slice(0, 50)}..."`);
-            const client = clients.get(accountId);
-            if (!client || client.connectionState !== 'connected') {
-                pluginLogger?.warn(`VoiceClaw: No connection for "${accountId}", reply dropped. clients: [${[...clients.keys()].join(',')}]`);
-                return { ok: false };
-            }
-            client.send({
-                type: 'agent_reply',
-                id: crypto.randomUUID(),
-                replyTo: '',
-                text,
-                ts: new Date().toISOString(),
-            });
-            pluginLogger?.info(`VoiceClaw: Reply sent to "${accountId}"`);
-            return { ok: true };
+    // ── Setup adapter (required for `openclaw channels add`) ─────
+    setup: {
+        resolveAccountId: ({ accountId }) => accountId || 'default',
+        applyAccountName: ({ cfg, accountId, name }) => {
+            const accounts = { ...cfg.channels?.voiceclaw?.accounts };
+            const existing = accounts[accountId] ?? {};
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    voiceclaw: {
+                        ...cfg.channels?.voiceclaw,
+                        accounts: {
+                            ...accounts,
+                            [accountId]: { ...existing, name },
+                        },
+                    },
+                },
+            };
+        },
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const accounts = { ...cfg.channels?.voiceclaw?.accounts };
+            const existing = accounts[accountId] ?? {};
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    voiceclaw: {
+                        ...cfg.channels?.voiceclaw,
+                        accounts: {
+                            ...accounts,
+                            [accountId]: {
+                                ...existing,
+                                ...(input.pairingCode ? { pairingCode: input.pairingCode } : {}),
+                                enabled: true,
+                            },
+                        },
+                    },
+                },
+            };
         },
     },
+    // ── Onboarding (interactive setup via `openclaw channels add`) ─
     onboarding: {
         configure: async (ctx) => {
-            // Support: openclaw channels add --channel voiceclaw --token <code>
             let pairingCode = ctx.options?.token;
             if (!pairingCode && ctx.prompter) {
                 pairingCode = await ctx.prompter.text({
-                    message: 'Enter the 6-digit pairing code from the VoiceClaw app:',
+                    message: 'Enter the pairing code from the VoiceClaw app:',
                     validate: (v) => v.trim().length >= 4
                         ? undefined
                         : 'Pairing code must be at least 4 characters',
@@ -117,18 +180,72 @@ export const voiceClawPlugin = {
                 cfg.channels = {};
             if (!cfg.channels.voiceclaw)
                 cfg.channels.voiceclaw = {};
-            cfg.channels.voiceclaw.pairingCode = pairingCode.trim();
+            if (!cfg.channels.voiceclaw.accounts)
+                cfg.channels.voiceclaw.accounts = {};
+            cfg.channels.voiceclaw.accounts.default = {
+                pairingCode: pairingCode.trim(),
+                enabled: true,
+            };
             return { cfg, accountId: 'default' };
         },
     },
+    outbound: {
+        deliveryMode: 'direct',
+        sendText: async (params) => {
+            const accountId = params.accountId ?? 'default';
+            const text = params.text ?? '';
+            pluginLogger?.info(`VoiceClaw sendText: accountId="${accountId}", text="${text.slice(0, 50)}..."`);
+            const client = clients.get(accountId);
+            if (!client || client.connectionState !== 'connected') {
+                pluginLogger?.warn(`VoiceClaw: No connection for "${accountId}", reply dropped. clients: [${[...clients.keys()].join(',')}]`);
+                return { ok: false };
+            }
+            client.send({
+                type: 'agent_reply',
+                id: crypto.randomUUID(),
+                replyTo: '',
+                text,
+                ts: new Date().toISOString(),
+            });
+            pluginLogger?.info(`VoiceClaw: Reply sent to "${accountId}"`);
+            return { ok: true };
+        },
+    },
+    // ── Status adapter (matching WhatsApp's shape) ───────────────
+    status: {
+        defaultRuntime: {
+            accountId: 'default',
+            running: false,
+            connected: false,
+            lastMessageAt: null,
+            lastError: null,
+        },
+        buildChannelSummary: async ({ account, snapshot }) => {
+            const configured = loadSavedToken(account.accountId) !== null || Boolean(account.pairingCode);
+            return {
+                configured,
+                running: snapshot.running ?? false,
+                connected: snapshot.connected ?? false,
+                lastMessageAt: snapshot.lastMessageAt ?? null,
+                lastError: snapshot.lastError ?? null,
+            };
+        },
+        buildAccountSnapshot: async ({ account, runtime }) => ({
+            accountId: account.accountId,
+            enabled: account.enabled !== false,
+            configured: loadSavedToken(account.accountId) !== null || Boolean(account.pairingCode),
+            running: runtime?.running ?? false,
+            connected: runtime?.connected ?? false,
+            lastMessageAt: runtime?.lastMessageAt ?? null,
+            lastError: runtime?.lastError ?? null,
+        }),
+        resolveAccountState: ({ configured }) => configured ? 'paired' : 'not paired',
+    },
+    // ── Gateway (per-account start/stop) ─────────────────────────
     gateway: {
         startAccount: async (ctx) => {
             const account = ctx.account;
             const logger = pluginLogger;
-            // Capture the inbound handler from OpenClaw
-            if (ctx.processInbound) {
-                handleInbound = ctx.processInbound;
-            }
             logger.info(`VoiceClaw: Starting account "${account.accountId}"...`);
             try {
                 const sessionToken = await resolveToken(account.accountId, account, logger);
@@ -136,28 +253,70 @@ export const voiceClawPlugin = {
                 const client = new RelayWsClient({
                     token: sessionToken,
                     workerUrl,
-                    onUserMessage: (msg) => {
+                    onUserMessage: async (msg) => {
                         logger.info(`VoiceClaw: User message (${msg.id}): ${msg.text.slice(0, 50)}...`);
-                        handleInbound?.(msg.text, account.accountId);
+                        // Dispatch inbound message via OpenClaw runtime
+                        try {
+                            const inboundCtx = pluginRuntime.channel.reply.finalizeInboundContext({
+                                channelId: 'voiceclaw',
+                                accountId: account.accountId,
+                                sender: 'voiceclaw-user',
+                                chatType: 'dm',
+                                chatId: `voiceclaw:${account.accountId}`,
+                                text: msg.text,
+                                source: 'voiceclaw',
+                            });
+                            await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                                ctx: inboundCtx,
+                                cfg: pluginConfig,
+                                dispatcherOptions: {
+                                    deliver: async (_outPayload) => {
+                                        void _outPayload;
+                                    },
+                                    onError: (err) => {
+                                        logger.error(`VoiceClaw: Reply dispatch error: ${String(err)}`);
+                                    },
+                                },
+                            });
+                            // Update status
+                            ctx.setStatus?.({
+                                accountId: account.accountId,
+                                running: true,
+                                connected: true,
+                                lastMessageAt: new Date().toISOString(),
+                            });
+                            logger.info('VoiceClaw: Message dispatched to agent');
+                        }
+                        catch (err) {
+                            logger.error(`VoiceClaw: Failed to dispatch message: ${String(err)}`);
+                        }
                     },
                     onStateChange: (state) => {
                         logger.info(`VoiceClaw: [${account.accountId}] ${state}`);
+                        ctx.setStatus?.({
+                            accountId: account.accountId,
+                            running: true,
+                            connected: state === 'connected',
+                        });
                     },
                     logger,
                 });
                 client.start();
                 clients.set(account.accountId, client);
                 ctx.setStatus?.({
-                    ok: true,
-                    label: `VoiceClaw (${account.accountId})`,
+                    accountId: account.accountId,
+                    running: true,
+                    connected: false,
                 });
                 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}`,
+                    accountId: account.accountId,
+                    running: false,
+                    connected: false,
+                    lastError: String(err),
                 });
             }
         },
@@ -172,10 +331,13 @@ export const voiceClawPlugin = {
         },
     },
 };
-// ── Plugin entry point (object form) ───────────────────────────
+// ── Setters for plugin entry point ─────────────────────────────
 export function setLogger(logger) {
     pluginLogger = logger;
 }
-export function setInboundHandler(handler) {
-    handleInbound = handler;
+export function setRuntime(runtime) {
+    pluginRuntime = runtime;
+}
+export function setConfig(config) {
+    pluginConfig = config;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voiceclaw/voiceclaw-plugin",
-  "version": "1.1.6",
+  "version": "1.1.9",
   "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",
@@ -44,9 +44,6 @@
     "macos",
     "voice"
   ],
-  "peerDependencies": {
-    "openclaw": ">=2026.1.0"
-  },
   "dependencies": {
     "ws": "^8.18.0",
     "zod": "^3.24.0"