@clawvoice/voice-assistant 1.0.0

package/dist/cli.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetupWizard = runSetupWizard;
+exports.registerCLI = registerCLI;
+const health_1 = require("./diagnostics/health");
+function maskSecret(value) {
+    if (!value) {
+        return "(not set)";
+    }
+    if (value.length <= 4) {
+        return "****";
+    }
+    return `${value.slice(0, 4)}...`;
+}
+function normalizeChoice(value, options) {
+    const lowered = value.trim().toLowerCase();
+    return options.includes(lowered) ? lowered : "";
+}
+async function askNonEmpty(prompter, question) {
+    while (true) {
+        const answer = (await prompter.ask(question)).trim();
+        if (answer.length > 0) {
+            return answer;
+        }
+    }
+}
+async function askChoice(prompter, question, choices) {
+    while (true) {
+        const answer = normalizeChoice(await prompter.ask(question), choices);
+        if (answer.length > 0) {
+            return answer;
+        }
+    }
+}
+function createReadlinePrompter() {
+    const readline = require("node:readline/promises");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return {
+        ask: async (question) => rl.question(question),
+        close: () => rl.close()
+    };
+}
+async function saveConfig(api, values) {
+    const configStore = api.config;
+    if (typeof configStore.setMany === "function") {
+        await configStore.setMany(values);
+        return;
+    }
+    if (typeof configStore.set === "function") {
+        const entries = Object.entries(values);
+        for (const [key, value] of entries) {
+            await configStore.set(key, value);
+        }
+        return;
+    }
+    throw new Error("Config store is not writable in this runtime");
+}
+async function runSetupWizard(api, args, prompter = createReadlinePrompter()) {
+    const values = {};
+    const telephonyProvider = await askChoice(prompter, "Telephony provider (telnyx/twilio): ", ["telnyx", "twilio"]);
+    values.telephonyProvider = telephonyProvider;
+    if (telephonyProvider === "telnyx") {
+        values.telnyxApiKey = await askNonEmpty(prompter, "Telnyx API key: ");
+        values.telnyxConnectionId = await askNonEmpty(prompter, "Telnyx connection ID: ");
+        values.telnyxPhoneNumber = await askNonEmpty(prompter, "Telnyx phone number (E.164): ");
+    }
+    else {
+        values.twilioAccountSid = await askNonEmpty(prompter, "Twilio Account SID: ");
+        values.twilioAuthToken = await askNonEmpty(prompter, "Twilio auth token: ");
+        values.twilioPhoneNumber = await askNonEmpty(prompter, "Twilio phone number (E.164): ");
+    }
+    const voiceProvider = await askChoice(prompter, "Voice provider (deepgram-agent/elevenlabs-conversational): ", ["deepgram-agent", "elevenlabs-conversational"]);
+    values.voiceProvider = voiceProvider;
+    values.deepgramApiKey = await askNonEmpty(prompter, "Deepgram API key: ");
+    if (voiceProvider === "elevenlabs-conversational") {
+        values.elevenlabsApiKey = await askNonEmpty(prompter, "ElevenLabs API key: ");
+        values.elevenlabsAgentId = await askNonEmpty(prompter, "ElevenLabs agent ID: ");
+    }
+    await saveConfig(api, values);
+    api.log.info("ClawVoice setup complete", {
+        telephonyProvider,
+        voiceProvider,
+        deepgramApiKey: maskSecret(String(values.deepgramApiKey)),
+        telnyxApiKey: maskSecret(typeof values.telnyxApiKey === "string" ? values.telnyxApiKey : undefined),
+        twilioAccountSid: maskSecret(typeof values.twilioAccountSid === "string" ? values.twilioAccountSid : undefined),
+        elevenlabsApiKey: maskSecret(typeof values.elevenlabsApiKey === "string" ? values.elevenlabsApiKey : undefined)
+    });
+    prompter.close();
+}
+function parseFlag(args, flag) {
+    const inline = args.find((a) => a.startsWith(`--${flag}=`));
+    if (inline)
+        return inline.slice(`--${flag}=`.length).trim() || undefined;
+    const idx = args.indexOf(`--${flag}`);
+    if (idx >= 0 && typeof args[idx + 1] === "string")
+        return args[idx + 1].trim() || undefined;
+    return undefined;
+}
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const remaining = seconds % 60;
+    return minutes > 0 ? `${minutes}m ${remaining}s` : `${seconds}s`;
+}
+function registerCLI(api, config, callService, memoryService) {
+    api.cli.register({
+        name: "clawvoice setup",
+        description: "Set up ClawVoice (configure telephony and voice providers)",
+        run: async (args) => {
+            await runSetupWizard(api, args);
+        },
+    });
+    api.cli.register({
+        name: "clawvoice call",
+        description: "Initiate an outbound phone call",
+        run: async (args) => {
+            const phoneNumber = args.find((a) => !a.startsWith("--"));
+            if (!phoneNumber) {
+                api.log.info("Usage: clawvoice call <phone-number> [--greeting \"...\"] [--purpose \"...\"]");
+                return;
+            }
+            const greeting = parseFlag(args, "greeting");
+            const purpose = parseFlag(args, "purpose");
+            api.log.info("Initiating call...", { to: phoneNumber });
+            try {
+                const result = await callService.startCall({ phoneNumber, greeting, purpose });
+                api.log.info("Call started", {
+                    callId: result.callId,
+                    to: result.to,
+                    greeting: result.openingGreeting,
+                    status: result.message,
+                });
+            }
+            catch (err) {
+                api.log.info("Call failed", { error: err instanceof Error ? err.message : String(err) });
+            }
+        },
+    });
+    api.cli.register({
+        name: "clawvoice status",
+        description: "Show active calls and configuration health diagnostics",
+        run: async () => {
+            const report = (0, health_1.runDiagnostics)(config);
+            api.log.info(`Diagnostics: ${report.overall.toUpperCase()}`, {});
+            for (const check of report.checks) {
+                const icon = check.status === "pass" ? "✓" : check.status === "warn" ? "⚠" : "✗";
+                api.log.info(`  ${icon} ${check.name}: ${check.detail}`, {});
+                if (check.remediation) {
+                    api.log.info(`    → ${check.remediation}`, {});
+                }
+            }
+            const active = callService.getActiveCalls();
+            if (active.length > 0) {
+                api.log.info(`Active calls: ${active.length}`, {});
+            }
+        },
+    });
+    api.cli.register({
+        name: "clawvoice promote",
+        description: "Review and promote voice memories to main MEMORY.md",
+        run: async (args) => {
+            if (!memoryService) {
+                api.log.info("Memory extraction service not available.");
+                return;
+            }
+            const memoryId = args.find((a) => !a.startsWith("--"));
+            if (memoryId) {
+                const candidate = memoryService.getCandidate(memoryId);
+                if (!candidate) {
+                    api.log.info("Memory candidate not found", { memoryId });
+                    return;
+                }
+                if (parseFlag(args, "--yes")) {
+                    const result = await memoryService.approveAndPromote(memoryId);
+                    api.log.info(result.promoted ? "Promoted" : `Failed: ${result.reason}`, { memoryId });
+                }
+                else {
+                    api.log.info(`[${candidate.status}] ${candidate.category}: "${candidate.content}" (confidence: ${candidate.confidence})`);
+                    api.log.info("Run again with --yes to promote.");
+                }
+                return;
+            }
+            const pending = memoryService.getPendingCandidates();
+            if (pending.length === 0) {
+                api.log.info("No pending memory candidates.");
+                return;
+            }
+            api.log.info(`${pending.length} pending memory candidate(s):`);
+            for (const c of pending) {
+                api.log.info(`  ${c.id}: [${c.category}] "${c.content}" (confidence: ${c.confidence})`);
+            }
+            api.log.info("Run `clawvoice promote <memoryId> --yes` to promote.");
+        },
+    });
+    api.cli.register({
+        name: "clawvoice history",
+        description: "Show recent call history",
+        run: async (args) => {
+            const callId = args.find((a) => !a.startsWith("--"));
+            if (callId) {
+                const summary = callService.getCallSummary(callId);
+                if (!summary) {
+                    api.log.info("No summary found for call", { callId });
+                    return;
+                }
+                const transcript = summary.transcriptLength > 0
+                    ? `${summary.transcriptLength} transcript entries`
+                    : "No transcript";
+                api.log.info("Call detail", {
+                    callId: summary.callId,
+                    outcome: summary.outcome,
+                    duration: formatDuration(summary.durationMs),
+                    transcript,
+                    failures: summary.failures.length > 0
+                        ? summary.failures.map((f) => `${f.type}: ${f.description}`).join("; ")
+                        : "none",
+                    pendingActions: summary.pendingActions.length > 0
+                        ? summary.pendingActions.join(", ")
+                        : "none",
+                    retryContext: summary.retryContext
+                        ? summary.retryContext.suggestedApproach
+                        : "none",
+                });
+                return;
+            }
+            const active = callService.getActiveCalls();
+            if (active.length === 0) {
+                api.log.info("No recent calls.");
+                return;
+            }
+            for (const call of active) {
+                api.log.info("Call", {
+                    callId: call.callId,
+                    to: call.to,
+                    provider: call.provider,
+                    status: call.status,
+                    started: call.startedAt,
+                    ended: call.endedAt ?? "ongoing",
+                });
+            }
+        },
+    });
+    api.cli.register({
+        name: "clawvoice test",
+        description: "Test voice pipeline connectivity and provider readiness",
+        run: async () => {
+            const report = (0, health_1.runDiagnostics)(config);
+            const failures = report.checks.filter((c) => c.status === "fail");
+            if (failures.length > 0) {
+                api.log.info("Connectivity test FAILED — fix these issues first:", {});
+                for (const f of failures) {
+                    api.log.info(`  ✗ ${f.name}: ${f.detail}`, {});
+                    if (f.remediation) {
+                        api.log.info(`    → ${f.remediation}`, {});
+                    }
+                }
+                return;
+            }
+            api.log.info("Connectivity test PASSED — all providers configured.", {});
+            const warnings = report.checks.filter((c) => c.status === "warn");
+            if (warnings.length > 0) {
+                api.log.info("Warnings:", {});
+                for (const w of warnings) {
+                    api.log.info(`  ⚠ ${w.name}: ${w.detail}`, {});
+                }
+            }
+        },
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,42 @@
+export type TelephonyProvider = "telnyx" | "twilio";
+export type VoiceProvider = "deepgram-agent" | "elevenlabs-conversational";
+export type MainMemoryAccess = "read" | "none";
+export interface ClawVoiceConfig {
+    telephonyProvider: TelephonyProvider;
+    voiceProvider: VoiceProvider;
+    voiceSystemPrompt: string;
+    inboundEnabled: boolean;
+    telnyxApiKey?: string;
+    telnyxConnectionId?: string;
+    telnyxPhoneNumber?: string;
+    telnyxWebhookSecret?: string;
+    twilioAccountSid?: string;
+    twilioAuthToken?: string;
+    twilioPhoneNumber?: string;
+    deepgramApiKey?: string;
+    deepgramVoice: string;
+    elevenlabsApiKey?: string;
+    elevenlabsAgentId?: string;
+    elevenlabsVoiceId?: string;
+    openaiApiKey?: string;
+    analysisModel: string;
+    mainMemoryAccess: MainMemoryAccess;
+    autoExtractMemories: boolean;
+    maxCallDuration: number;
+    disclosureEnabled: boolean;
+    disclosureStatement: string;
+    dailyCallLimit: number;
+    recordCalls: boolean;
+    amdEnabled: boolean;
+    restrictTools: boolean;
+    deniedTools: string[];
+    notifyTelegram: boolean;
+    notifyDiscord: boolean;
+    notifySlack: boolean;
+}
+export interface ValidationResult {
+    ok: boolean;
+    errors: string[];
+}
+export declare function resolveConfig(pluginConfig?: Record<string, unknown>, env?: NodeJS.ProcessEnv): ClawVoiceConfig;
+export declare function validateConfig(config: ClawVoiceConfig): ValidationResult;

package/dist/config.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.validateConfig = validateConfig;
+const DEFAULT_CONFIG = {
+    telephonyProvider: "twilio",
+    voiceProvider: "deepgram-agent",
+    voiceSystemPrompt: "",
+    inboundEnabled: true,
+    deepgramVoice: "aura-asteria-en",
+    analysisModel: "gpt-4o-mini",
+    mainMemoryAccess: "read",
+    autoExtractMemories: true,
+    maxCallDuration: 1800,
+    disclosureEnabled: true,
+    disclosureStatement: "Hello, this call is from an AI assistant calling on behalf of a user.",
+    dailyCallLimit: 50,
+    recordCalls: false,
+    amdEnabled: true,
+    restrictTools: true,
+    deniedTools: [
+        "exec",
+        "browser",
+        "web_fetch",
+        "gateway",
+        "cron",
+        "sessions_spawn"
+    ],
+    notifyTelegram: false,
+    notifyDiscord: false,
+    notifySlack: false,
+};
+function parseBoolean(value, fallback) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+    }
+    return fallback;
+}
+function parseMainMemoryAccess(value) {
+    return value === "read" || value === "none" ? value : undefined;
+}
+function parseNumber(value, fallback) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number.parseInt(value, 10);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function parseStringArray(value, fallback) {
+    if (Array.isArray(value)) {
+        const filtered = value.filter((entry) => typeof entry === "string");
+        return filtered.length > 0 ? filtered : fallback;
+    }
+    if (typeof value === "string") {
+        const items = value
+            .split(",")
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        return items.length > 0 ? items : fallback;
+    }
+    return fallback;
+}
+function envString(env, key) {
+    const value = env[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function getValue(envValue, configValue, fallback) {
+    if (typeof envValue !== "undefined") {
+        return envValue;
+    }
+    if (typeof configValue !== "undefined") {
+        return configValue;
+    }
+    return fallback;
+}
+function parseTelephonyProvider(value) {
+    return value === "telnyx" || value === "twilio" ? value : undefined;
+}
+function parseVoiceProvider(value) {
+    return value === "deepgram-agent" || value === "elevenlabs-conversational" ? value : undefined;
+}
+function resolveConfig(pluginConfig = {}, env = process.env) {
+    const envTelephony = parseTelephonyProvider(envString(env, "CLAWVOICE_TELEPHONY_PROVIDER"));
+    const envVoice = parseVoiceProvider(envString(env, "CLAWVOICE_VOICE_PROVIDER"));
+    const envTelnyxApiKey = envString(env, "TELNYX_API_KEY");
+    const envTelnyxConnectionId = envString(env, "TELNYX_CONNECTION_ID");
+    const envTelnyxPhoneNumber = envString(env, "TELNYX_PHONE_NUMBER");
+    const envTelnyxWebhookSecret = envString(env, "TELNYX_WEBHOOK_SECRET");
+    const envTwilioAccountSid = envString(env, "TWILIO_ACCOUNT_SID");
+    const envTwilioAuthToken = envString(env, "TWILIO_AUTH_TOKEN");
+    const envTwilioPhoneNumber = envString(env, "TWILIO_PHONE_NUMBER");
+    const envDeepgramApiKey = envString(env, "DEEPGRAM_API_KEY");
+    const envDeepgramVoice = envString(env, "CLAWVOICE_DEEPGRAM_VOICE");
+    const envElevenlabsApiKey = envString(env, "ELEVENLABS_API_KEY");
+    const envElevenlabsAgentId = envString(env, "ELEVENLABS_AGENT_ID");
+    const envElevenlabsVoiceId = envString(env, "ELEVENLABS_VOICE_ID");
+    const envOpenaiApiKey = envString(env, "OPENAI_API_KEY");
+    const envAnalysisModel = envString(env, "CLAWVOICE_ANALYSIS_MODEL");
+    const envMainMemoryAccess = parseMainMemoryAccess(envString(env, "CLAWVOICE_MAIN_MEMORY_ACCESS"));
+    const envAutoExtractMemories = envString(env, "CLAWVOICE_AUTO_EXTRACT_MEMORIES");
+    const envMaxCallDuration = envString(env, "CLAWVOICE_MAX_CALL_DURATION");
+    const envRecordCalls = envString(env, "CLAWVOICE_RECORD_CALLS");
+    const envDisclosureEnabled = envString(env, "CLAWVOICE_DISCLOSURE_ENABLED");
+    const envDisclosureStatement = envString(env, "CLAWVOICE_DISCLOSURE_STATEMENT");
+    const envAmdEnabled = envString(env, "CLAWVOICE_AMD_ENABLED");
+    const envRestrictTools = envString(env, "CLAWVOICE_RESTRICT_TOOLS");
+    const envDeniedTools = envString(env, "CLAWVOICE_DENIED_TOOLS");
+    const envVoiceSystemPrompt = envString(env, "CLAWVOICE_VOICE_SYSTEM_PROMPT");
+    const envInboundEnabled = envString(env, "CLAWVOICE_INBOUND_ENABLED");
+    const envDailyCallLimit = envString(env, "CLAWVOICE_DAILY_CALL_LIMIT");
+    const configTelephony = parseTelephonyProvider(pluginConfig.telephonyProvider);
+    const configVoice = parseVoiceProvider(pluginConfig.voiceProvider);
+    const configMainMemoryAccess = parseMainMemoryAccess(pluginConfig.mainMemoryAccess);
+    return {
+        telephonyProvider: getValue(envTelephony, configTelephony, DEFAULT_CONFIG.telephonyProvider),
+        voiceProvider: getValue(envVoice, configVoice, DEFAULT_CONFIG.voiceProvider),
+        telnyxApiKey: getValue(envTelnyxApiKey, typeof pluginConfig.telnyxApiKey === "string" ? pluginConfig.telnyxApiKey : undefined, undefined),
+        telnyxConnectionId: getValue(envTelnyxConnectionId, typeof pluginConfig.telnyxConnectionId === "string" ? pluginConfig.telnyxConnectionId : undefined, undefined),
+        telnyxPhoneNumber: getValue(envTelnyxPhoneNumber, typeof pluginConfig.telnyxPhoneNumber === "string" ? pluginConfig.telnyxPhoneNumber : undefined, undefined),
+        telnyxWebhookSecret: getValue(envTelnyxWebhookSecret, typeof pluginConfig.telnyxWebhookSecret === "string" ? pluginConfig.telnyxWebhookSecret : undefined, undefined),
+        twilioAccountSid: getValue(envTwilioAccountSid, typeof pluginConfig.twilioAccountSid === "string" ? pluginConfig.twilioAccountSid : undefined, undefined),
+        twilioAuthToken: getValue(envTwilioAuthToken, typeof pluginConfig.twilioAuthToken === "string" ? pluginConfig.twilioAuthToken : undefined, undefined),
+        twilioPhoneNumber: getValue(envTwilioPhoneNumber, typeof pluginConfig.twilioPhoneNumber === "string" ? pluginConfig.twilioPhoneNumber : undefined, undefined),
+        deepgramApiKey: getValue(envDeepgramApiKey, typeof pluginConfig.deepgramApiKey === "string" ? pluginConfig.deepgramApiKey : undefined, undefined),
+        deepgramVoice: getValue(envDeepgramVoice, typeof pluginConfig.deepgramVoice === "string" ? pluginConfig.deepgramVoice : undefined, DEFAULT_CONFIG.deepgramVoice),
+        elevenlabsApiKey: getValue(envElevenlabsApiKey, typeof pluginConfig.elevenlabsApiKey === "string" ? pluginConfig.elevenlabsApiKey : undefined, undefined),
+        elevenlabsAgentId: getValue(envElevenlabsAgentId, typeof pluginConfig.elevenlabsAgentId === "string" ? pluginConfig.elevenlabsAgentId : undefined, undefined),
+        elevenlabsVoiceId: getValue(envElevenlabsVoiceId, typeof pluginConfig.elevenlabsVoiceId === "string" ? pluginConfig.elevenlabsVoiceId : undefined, undefined),
+        openaiApiKey: getValue(envOpenaiApiKey, typeof pluginConfig.openaiApiKey === "string" ? pluginConfig.openaiApiKey : undefined, undefined),
+        analysisModel: getValue(envAnalysisModel, typeof pluginConfig.analysisModel === "string" ? pluginConfig.analysisModel : undefined, DEFAULT_CONFIG.analysisModel),
+        mainMemoryAccess: getValue(envMainMemoryAccess, configMainMemoryAccess, DEFAULT_CONFIG.mainMemoryAccess),
+        autoExtractMemories: parseBoolean(getValue(envAutoExtractMemories, typeof pluginConfig.autoExtractMemories === "undefined" ? undefined : String(pluginConfig.autoExtractMemories), String(DEFAULT_CONFIG.autoExtractMemories)), DEFAULT_CONFIG.autoExtractMemories),
+        maxCallDuration: parseNumber(getValue(envMaxCallDuration, typeof pluginConfig.maxCallDuration === "undefined" ? undefined : String(pluginConfig.maxCallDuration), String(DEFAULT_CONFIG.maxCallDuration)), DEFAULT_CONFIG.maxCallDuration),
+        disclosureEnabled: parseBoolean(getValue(envDisclosureEnabled, typeof pluginConfig.disclosureEnabled === "undefined"
+            ? undefined
+            : String(pluginConfig.disclosureEnabled), String(DEFAULT_CONFIG.disclosureEnabled)), DEFAULT_CONFIG.disclosureEnabled),
+        disclosureStatement: getValue(envDisclosureStatement, typeof pluginConfig.disclosureStatement === "string"
+            ? pluginConfig.disclosureStatement
+            : undefined, DEFAULT_CONFIG.disclosureStatement),
+        dailyCallLimit: parseNumber(getValue(envDailyCallLimit, typeof pluginConfig.dailyCallLimit === "undefined" ? undefined : String(pluginConfig.dailyCallLimit), String(DEFAULT_CONFIG.dailyCallLimit)), DEFAULT_CONFIG.dailyCallLimit),
+        recordCalls: parseBoolean(getValue(envRecordCalls, typeof pluginConfig.recordCalls === "undefined" ? undefined : String(pluginConfig.recordCalls), String(DEFAULT_CONFIG.recordCalls)), DEFAULT_CONFIG.recordCalls),
+        amdEnabled: parseBoolean(getValue(envAmdEnabled, typeof pluginConfig.amdEnabled === "undefined" ? undefined : String(pluginConfig.amdEnabled), String(DEFAULT_CONFIG.amdEnabled)), DEFAULT_CONFIG.amdEnabled),
+        voiceSystemPrompt: getValue(envVoiceSystemPrompt, typeof pluginConfig.voiceSystemPrompt === "string" ? pluginConfig.voiceSystemPrompt : undefined, DEFAULT_CONFIG.voiceSystemPrompt),
+        inboundEnabled: parseBoolean(getValue(envInboundEnabled, typeof pluginConfig.inboundEnabled === "undefined" ? undefined : String(pluginConfig.inboundEnabled), String(DEFAULT_CONFIG.inboundEnabled)), DEFAULT_CONFIG.inboundEnabled),
+        restrictTools: parseBoolean(getValue(envRestrictTools, typeof pluginConfig.restrictTools === "undefined" ? undefined : String(pluginConfig.restrictTools), String(DEFAULT_CONFIG.restrictTools)), DEFAULT_CONFIG.restrictTools),
+        deniedTools: parseStringArray(getValue(envDeniedTools, pluginConfig.deniedTools, DEFAULT_CONFIG.deniedTools), DEFAULT_CONFIG.deniedTools),
+        notifyTelegram: parseBoolean(getValue(envString(env, "CLAWVOICE_NOTIFY_TELEGRAM"), typeof pluginConfig.notifyTelegram === "undefined" ? undefined : String(pluginConfig.notifyTelegram), String(DEFAULT_CONFIG.notifyTelegram)), DEFAULT_CONFIG.notifyTelegram),
+        notifyDiscord: parseBoolean(getValue(envString(env, "CLAWVOICE_NOTIFY_DISCORD"), typeof pluginConfig.notifyDiscord === "undefined" ? undefined : String(pluginConfig.notifyDiscord), String(DEFAULT_CONFIG.notifyDiscord)), DEFAULT_CONFIG.notifyDiscord),
+        notifySlack: parseBoolean(getValue(envString(env, "CLAWVOICE_NOTIFY_SLACK"), typeof pluginConfig.notifySlack === "undefined" ? undefined : String(pluginConfig.notifySlack), String(DEFAULT_CONFIG.notifySlack)), DEFAULT_CONFIG.notifySlack),
+    };
+}
+function validateConfig(config) {
+    const validationErrors = [];
+    if (!Number.isFinite(config.maxCallDuration) || config.maxCallDuration <= 0) {
+        validationErrors.push("maxCallDuration must be a positive number of seconds");
+    }
+    if (config.disclosureEnabled &&
+        config.disclosureStatement.trim().length === 0) {
+        validationErrors.push("disclosureStatement must be non-empty when disclosureEnabled is true");
+    }
+    if (validationErrors.length === 0) {
+        return { ok: true, errors: [] };
+    }
+    return {
+        ok: false,
+        errors: validationErrors,
+    };
+}

package/dist/diagnostics/health.d.ts

@@ -0,0 +1,14 @@
+import { ClawVoiceConfig } from "../config";
+export type CheckStatus = "pass" | "warn" | "fail";
+export interface HealthCheck {
+    name: string;
+    status: CheckStatus;
+    detail: string;
+    remediation?: string;
+}
+export interface DiagnosticReport {
+    overall: CheckStatus;
+    checks: HealthCheck[];
+    generatedAt: string;
+}
+export declare function runDiagnostics(config: ClawVoiceConfig): DiagnosticReport;