@voiceclaw/voiceclaw-plugin 1.0.9 → 1.1.1

package/dist/index.d.ts

@@ -9,5 +9,25 @@ interface PluginApi {
         plugin: any;
     }) => void;
 }
-export default function register(api: PluginApi): void;
-export {};
+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

@@ -1,172 +1,13 @@
-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');
-}
+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/package.json

@@ -1,25 +1,10 @@
 {
   "name": "@voiceclaw/voiceclaw-plugin",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "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",
@@ -41,22 +26,40 @@
       ]
     },
     "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",
+    "prepublishOnly": "npm run build"
   }
 }

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';