@alliance-droid/chat-widget 0.1.0

package/dist/server/session.js

@@ -0,0 +1,115 @@
+/**
+ * Session Manager
+ *
+ * In-memory session storage (Redis adapter TODO)
+ */
+export class SessionManager {
+    sessions = new Map();
+    ttl;
+    cleanupInterval;
+    constructor(ttlMs = 24 * 60 * 60 * 1000) {
+        this.ttl = ttlMs;
+        // Cleanup expired sessions every hour
+        this.cleanupInterval = setInterval(() => this.cleanup(), 60 * 60 * 1000);
+    }
+    /**
+     * Create a new session
+     */
+    create(userId, userMeta) {
+        const id = this.generateId();
+        const now = Date.now();
+        const session = {
+            id,
+            status: 'ai',
+            messages: [],
+            userId,
+            userMeta,
+            createdAt: now,
+            updatedAt: now
+        };
+        this.sessions.set(id, session);
+        return session;
+    }
+    /**
+     * Get a session by ID
+     */
+    get(id) {
+        const session = this.sessions.get(id);
+        if (session && this.isExpired(session)) {
+            this.sessions.delete(id);
+            return undefined;
+        }
+        return session;
+    }
+    /**
+     * Add a message to a session
+     */
+    addMessage(sessionId, message) {
+        const session = this.get(sessionId);
+        if (!session)
+            return;
+        session.messages.push(message);
+        session.updatedAt = Date.now();
+    }
+    /**
+     * Update session status
+     */
+    setStatus(sessionId, status) {
+        const session = this.get(sessionId);
+        if (!session)
+            return;
+        session.status = status;
+        session.updatedAt = Date.now();
+    }
+    /**
+     * Assign a support agent to a session
+     */
+    assignSupport(sessionId, agentId) {
+        const session = this.get(sessionId);
+        if (!session)
+            return false;
+        // Don't reassign if already assigned
+        if (session.supportAgentId)
+            return false;
+        session.supportAgentId = agentId;
+        session.status = 'human';
+        session.updatedAt = Date.now();
+        return true;
+    }
+    /**
+     * Delete a session
+     */
+    delete(id) {
+        this.sessions.delete(id);
+    }
+    /**
+     * Cleanup expired sessions
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [id, session] of this.sessions) {
+            if (this.isExpired(session)) {
+                this.sessions.delete(id);
+            }
+        }
+    }
+    /**
+     * Check if session is expired
+     */
+    isExpired(session) {
+        return Date.now() - session.updatedAt > this.ttl;
+    }
+    /**
+     * Generate unique session ID
+     */
+    generateId() {
+        return `${Date.now().toString(36)}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Cleanup on shutdown
+     */
+    destroy() {
+        clearInterval(this.cleanupInterval);
+        this.sessions.clear();
+    }
+}

package/dist/stores/chat.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Chat Store
+ *
+ * Manages chat messages, status, and typing indicators
+ */
+import type { Message, ChatStatus } from '../types.js';
+export declare const chatStore: {
+    messages: import("svelte/store").Writable<Message[]>;
+    status: import("svelte/store").Writable<ChatStatus>;
+    isTyping: import("svelte/store").Writable<boolean>;
+    typingSender: import("svelte/store").Writable<"ai" | "human" | null>;
+    addMessage(message: Message): void;
+    updateMessage(id: string, updates: Partial<Message>): void;
+    setStatus(newStatus: ChatStatus): void;
+    setTyping(typing: boolean, sender?: "ai" | "human" | null): void;
+    clear(): void;
+    messageCount: import("svelte/store").Readable<number>;
+};

package/dist/stores/chat.js

@@ -0,0 +1,40 @@
+/**
+ * Chat Store
+ *
+ * Manages chat messages, status, and typing indicators
+ */
+import { writable, derived } from 'svelte/store';
+function createChatStore() {
+    const messages = writable([]);
+    const status = writable('idle');
+    const isTyping = writable(false);
+    const typingSender = writable(null);
+    return {
+        messages,
+        status,
+        isTyping,
+        typingSender,
+        addMessage(message) {
+            messages.update(msgs => [...msgs, message]);
+        },
+        updateMessage(id, updates) {
+            messages.update(msgs => msgs.map(msg => (msg.id === id ? { ...msg, ...updates } : msg)));
+        },
+        setStatus(newStatus) {
+            status.set(newStatus);
+        },
+        setTyping(typing, sender = null) {
+            isTyping.set(typing);
+            typingSender.set(sender);
+        },
+        clear() {
+            messages.set([]);
+            status.set('idle');
+            isTyping.set(false);
+            typingSender.set(null);
+        },
+        // Derived store for message count
+        messageCount: derived(messages, $messages => $messages.length)
+    };
+}
+export const chatStore = createChatStore();

package/dist/stores/connection.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Connection Store
+ *
+ * Manages WebSocket connection state
+ */
+import type { ConnectionState } from '../types.js';
+export declare const connectionStore: {
+    state: import("svelte/store").Writable<ConnectionState>;
+    sessionId: import("svelte/store").Writable<string | null>;
+    error: import("svelte/store").Writable<string | null>;
+    reconnectAttempts: import("svelte/store").Writable<number>;
+    setConnected(newSessionId: string): void;
+    setConnecting(): void;
+    setReconnecting(): void;
+    setDisconnected(errorMessage?: string): void;
+    setError(errorMessage: string): void;
+    clearError(): void;
+    reset(): void;
+    isConnected: import("svelte/store").Readable<boolean>;
+};

package/dist/stores/connection.js

@@ -0,0 +1,52 @@
+/**
+ * Connection Store
+ *
+ * Manages WebSocket connection state
+ */
+import { writable, derived } from 'svelte/store';
+function createConnectionStore() {
+    const state = writable('disconnected');
+    const sessionId = writable(null);
+    const error = writable(null);
+    const reconnectAttempts = writable(0);
+    return {
+        state,
+        sessionId,
+        error,
+        reconnectAttempts,
+        setConnected(newSessionId) {
+            state.set('connected');
+            sessionId.set(newSessionId);
+            error.set(null);
+            reconnectAttempts.set(0);
+        },
+        setConnecting() {
+            state.set('connecting');
+        },
+        setReconnecting() {
+            state.set('reconnecting');
+            reconnectAttempts.update(n => n + 1);
+        },
+        setDisconnected(errorMessage) {
+            state.set('disconnected');
+            if (errorMessage) {
+                error.set(errorMessage);
+            }
+        },
+        setError(errorMessage) {
+            error.set(errorMessage);
+        },
+        clearError() {
+            error.set(null);
+        },
+        reset() {
+            state.set('disconnected');
+            sessionId.set(null);
+            error.set(null);
+            reconnectAttempts.set(0);
+        },
+        // Derived store for connection status
+        isConnected: derived(state, $state => $state === 'connected')
+    };
+}
+export const connectionStore = createConnectionStore();

package/dist/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Chat Widget Types
+ */
+export interface Message {
+    id: string;
+    content: string;
+    sender: 'user' | 'ai' | 'human' | 'system';
+    timestamp: number;
+    streaming?: boolean;
+}
+export interface ClientMessage {
+    type: 'message' | 'escalate' | 'typing' | 'read' | 'join';
+    sessionId?: string;
+    content?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ServerMessage {
+    type: 'message' | 'typing' | 'status' | 'error' | 'escalated' | 'connected' | 'auth_success' | 'auth_error';
+    id?: string;
+    content?: string;
+    sender?: 'user' | 'ai' | 'human' | 'system';
+    timestamp?: number;
+    streaming?: boolean;
+    sessionId?: string;
+    error?: string;
+}
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+export type ChatStatus = 'idle' | 'ai' | 'escalating' | 'human' | 'closed';
+export interface ChatWidgetProps {
+    serverUrl: string;
+    apiKey?: string;
+    reconnect?: boolean;
+    reconnectInterval?: number;
+    theme?: 'light' | 'dark' | 'auto';
+    position?: 'bottom-right' | 'bottom-left';
+    greeting?: string;
+    placeholder?: string;
+    fabIcon?: string;
+    enableSounds?: boolean;
+    enableEscalation?: boolean;
+    escalationLabel?: string;
+    userId?: string;
+    userMeta?: Record<string, unknown>;
+    class?: string;
+}
+export interface SupportChatProps {
+    serverUrl: string;
+    sessionId: string;
+    class?: string;
+}
+export interface ChatServerConfig {
+    ai: AIProviderConfig;
+    escalation?: EscalationConfig;
+    storage?: 'memory' | 'redis';
+    sessionTTL?: number;
+}
+export interface AIProviderConfig {
+    provider: 'xai' | 'openai' | 'anthropic';
+    apiKey: string;
+    model?: string;
+    systemPrompt?: string;
+}
+export interface EscalationConfig {
+    telegram: {
+        botToken: string;
+        chatId: string;
+    };
+    joinUrl: (sessionId: string) => string;
+}
+export interface ChatSession {
+    id: string;
+    status: ChatStatus;
+    messages: Message[];
+    userId?: string;
+    userMeta?: Record<string, unknown>;
+    supportAgentId?: string;
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Chat Widget Types
+ */
+export {};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@alliance-droid/chat-widget",
+  "version": "0.1.0",
+  "description": "Svelte chat widget with AI support and human escalation",
+  "type": "module",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "build:package": "svelte-kit sync && svelte-package && publint",
+    "preview": "vite preview",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build:package"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "default": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-auto": "^4.0.0",
+    "@sveltejs/kit": "^2.16.0",
+    "@sveltejs/package": "^2.3.0",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "autoprefixer": "^10.4.0",
+    "postcss": "^8.4.0",
+    "publint": "^0.3.0",
+    "svelte": "^5.0.0",
+    "svelte-check": "^4.0.0",
+    "tailwindcss": "^3.4.0",
+    "typescript": "^5.0.0",
+    "vite": "^6.0.0",
+    "vitest": "^2.0.0"
+  },
+  "dependencies": {
+    "@alliance-droid/svelte-component-library": "^0.1.0",
+    "ws": "^8.18.0"
+  },
+  "keywords": [
+    "svelte",
+    "chat",
+    "widget",
+    "ai",
+    "support",
+    "customer-service"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alliance-droid/chat-widget"
+  }
+}