tacel-chat 1.2.0

package/chat-api.js

@@ -0,0 +1,436 @@
+/**
+ * tacel-chat — Backend IPC handler factory
+ * Registers all chat IPC handlers using app-provided database functions.
+ * This is optional — apps can implement their own handlers instead.
+ */
+
+function normalizeUsername(username) {
+  return (username || '').trim().toLowerCase();
+}
+
+/**
+ * Initialize chat IPC handlers
+ * @param {object} ipcMain - Electron ipcMain
+ * @param {object} options
+ * @param {string} options.channelPrefix - Optional prefix for IPC channels
+ * @param {Function} options.dbQuery - (sql, params) => Promise<Array>
+ * @param {Function} options.dbGetOne - (sql, params) => Promise<object|null>
+ * @param {Function} options.socketEmit - (event, payload) => void
+ * @param {Function} options.broadcastRenderer - (eventName, payload) => void (fallback)
+ */
+function initChatAPI(ipcMain, options = {}) {
+  const prefix = options.channelPrefix || '';
+  const dbQuery = options.dbQuery;
+  const dbGetOne = options.dbGetOne;
+  const socketEmit = options.socketEmit || (() => {});
+  const broadcastRenderer = options.broadcastRenderer || (() => {});
+
+  function ch(name) { return prefix + name; }
+
+  function emit(event, payload) {
+    try {
+      socketEmit(event, payload);
+    } catch {
+      broadcastRenderer(event, payload);
+    }
+  }
+
+  // ── List Users ──────────────────────────────────────────────
+  ipcMain.handle(ch('chat-list-users'), async () => {
+    try {
+      const rows = await dbQuery(
+        'SELECT id, username, app, is_online, last_seen, global_key FROM chat_users ORDER BY username'
+      );
+      return { success: true, data: rows };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-list-users error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Presence Heartbeat ──────────────────────────────────────
+  ipcMain.handle(ch('chat-presence-heartbeat'), async (event, { current_username }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      await dbQuery(
+        'UPDATE chat_users SET is_online = 1, last_seen = CURRENT_TIMESTAMP WHERE global_key = ?',
+        [gk]
+      );
+      return { success: true };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-presence-heartbeat error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Presence Offline ────────────────────────────────────────
+  ipcMain.handle(ch('chat-presence-offline'), async (event, { current_username }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      await dbQuery(
+        'UPDATE chat_users SET is_online = 0, last_seen = CURRENT_TIMESTAMP WHERE global_key = ?',
+        [gk]
+      );
+      return { success: true };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-presence-offline error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Get Direct Peers ────────────────────────────────────────
+  ipcMain.handle(ch('chat-get-direct-peers'), async (event, { current_username }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      const me = await dbGetOne('SELECT id FROM chat_users WHERE global_key = ?', [gk]);
+      if (!me) return { success: true, data: [] };
+
+      const rows = await dbQuery(`
+        SELECT DISTINCT p2.user_id
+        FROM chat_participants p1
+        JOIN chat_participants p2 ON p1.conversation_id = p2.conversation_id
+        JOIN chat_conversations c ON c.id = p1.conversation_id
+        WHERE p1.user_id = ? AND p2.user_id != ? AND c.type = 'direct'
+          AND p1.status = 'active' AND p2.status = 'active'
+      `, [me.id, me.id]);
+
+      return { success: true, data: rows.map(r => r.user_id) };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-get-direct-peers error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Get Conversations ───────────────────────────────────────
+  ipcMain.handle(ch('chat-get-conversations'), async (event, { current_username }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      const me = await dbGetOne('SELECT id FROM chat_users WHERE global_key = ?', [gk]);
+      if (!me) return { success: true, data: [] };
+
+      const rows = await dbQuery(`
+        SELECT c.id, c.type, c.name,
+          CASE
+            WHEN c.type = 'direct' THEN (
+              SELECT u.username FROM chat_participants p2
+              JOIN chat_users u ON u.id = p2.user_id
+              WHERE p2.conversation_id = c.id AND p2.user_id != ? AND p2.status = 'active'
+              LIMIT 1
+            )
+            ELSE c.name
+          END AS display_name,
+          (SELECT m.content FROM chat_messages m WHERE m.conversation_id = c.id ORDER BY m.timestamp DESC LIMIT 1) AS last_message,
+          (SELECT m.timestamp FROM chat_messages m WHERE m.conversation_id = c.id ORDER BY m.timestamp DESC LIMIT 1) AS last_timestamp
+        FROM chat_conversations c
+        JOIN chat_participants p ON p.conversation_id = c.id
+        WHERE p.user_id = ? AND p.status = 'active'
+        ORDER BY last_timestamp DESC
+      `, [me.id, me.id]);
+
+      return { success: true, data: rows };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-get-conversations error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Get Messages ────────────────────────────────────────────
+  ipcMain.handle(ch('chat-get-messages'), async (event, { conversation_id }) => {
+    try {
+      const rows = await dbQuery(`
+        SELECT m.id, m.content, m.timestamp, u.username AS sender, m.sender_id
+        FROM chat_messages m
+        JOIN chat_users u ON u.id = m.sender_id
+        WHERE m.conversation_id = ?
+        ORDER BY m.timestamp ASC
+      `, [conversation_id]);
+      return { success: true, data: rows };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-get-messages error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Start Direct Conversation ───────────────────────────────
+  ipcMain.handle(ch('chat-start-direct'), async (event, { current_username, other_user_id }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      const me = await dbGetOne('SELECT id FROM chat_users WHERE global_key = ?', [gk]);
+      if (!me) return { success: false, error: 'User not found' };
+
+      // Check for existing direct conversation
+      const existing = await dbGetOne(`
+        SELECT p1.conversation_id
+        FROM chat_participants p1
+        JOIN chat_participants p2 ON p1.conversation_id = p2.conversation_id
+        JOIN chat_conversations c ON c.id = p1.conversation_id
+        WHERE p1.user_id = ? AND p2.user_id = ? AND c.type = 'direct'
+          AND p1.status = 'active' AND p2.status = 'active'
+      `, [me.id, other_user_id]);
+
+      if (existing) {
+        return { success: true, conversation_id: existing.conversation_id };
+      }
+
+      // Create new conversation
+      const convResult = await dbQuery(
+        "INSERT INTO chat_conversations (type, created_by, created_at, updated_at) VALUES ('direct', ?, NOW(), NOW())",
+        [me.id]
+      );
+      const convId = convResult.insertId;
+
+      // Add participants
+      await dbQuery(
+        'INSERT INTO chat_participants (conversation_id, user_id, status, joined_at) VALUES (?, ?, \'active\', NOW())',
+        [convId, me.id]
+      );
+      await dbQuery(
+        'INSERT INTO chat_participants (conversation_id, user_id, status, joined_at) VALUES (?, ?, \'active\', NOW())',
+        [convId, other_user_id]
+      );
+
+      emit('chat:new_conversation', { conversation_id: convId });
+      return { success: true, conversation_id: convId };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-start-direct error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Send Message ────────────────────────────────────────────
+  ipcMain.handle(ch('chat-send-message'), async (event, { conversation_id, current_username, content }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      const me = await dbGetOne('SELECT id, username FROM chat_users WHERE global_key = ?', [gk]);
+      if (!me) return { success: false, error: 'User not found' };
+
+      const result = await dbQuery(
+        'INSERT INTO chat_messages (conversation_id, sender_id, content, timestamp) VALUES (?, ?, ?, NOW())',
+        [conversation_id, me.id, content]
+      );
+
+      // Touch conversation updated_at
+      await dbQuery('UPDATE chat_conversations SET updated_at = NOW() WHERE id = ?', [conversation_id]);
+
+      // Insert sender's own read receipt
+      await dbQuery(
+        'INSERT INTO chat_message_reads (message_id, user_id, read_at) VALUES (?, ?, NOW())',
+        [result.insertId, me.id]
+      );
+
+      emit('chat:new_message', {
+        conversation_id,
+        message_id: result.insertId,
+        sender: me.username,
+        sender_id: me.id,
+        content,
+        timestamp: new Date().toISOString()
+      });
+
+      return { success: true, message_id: result.insertId };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-send-message error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Get Unread Counts ───────────────────────────────────────
+  ipcMain.handle(ch('chat-get-unread-counts'), async (event, { current_username }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      const me = await dbGetOne('SELECT id FROM chat_users WHERE global_key = ?', [gk]);
+      if (!me) return { success: true, data: [] };
+
+      const rows = await dbQuery(`
+        SELECT m.conversation_id, COUNT(*) AS unread_count
+        FROM chat_messages m
+        JOIN chat_participants p ON p.conversation_id = m.conversation_id AND p.user_id = ? AND p.status = 'active'
+        WHERE m.sender_id != ?
+          AND NOT EXISTS (
+            SELECT 1 FROM chat_message_reads r WHERE r.message_id = m.id AND r.user_id = ?
+          )
+        GROUP BY m.conversation_id
+      `, [me.id, me.id, me.id]);
+
+      return { success: true, data: rows };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-get-unread-counts error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Mark Read ───────────────────────────────────────────────
+  ipcMain.handle(ch('chat-mark-read'), async (event, { conversation_id, current_username }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      const me = await dbGetOne('SELECT id FROM chat_users WHERE global_key = ?', [gk]);
+      if (!me) return { success: true, marked: 0 };
+
+      // Find unread messages from others
+      const unread = await dbQuery(`
+        SELECT m.id FROM chat_messages m
+        WHERE m.conversation_id = ? AND m.sender_id != ?
+          AND NOT EXISTS (
+            SELECT 1 FROM chat_message_reads r WHERE r.message_id = m.id AND r.user_id = ?
+          )
+      `, [conversation_id, me.id, me.id]);
+
+      for (const msg of unread) {
+        await dbQuery(
+          'INSERT INTO chat_message_reads (message_id, user_id, read_at) VALUES (?, ?, NOW())',
+          [msg.id, me.id]
+        );
+      }
+
+      if (unread.length > 0) {
+        emit('chat:read', { conversation_id, user_id: me.id, username: current_username });
+      }
+
+      return { success: true, marked: unread.length };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-mark-read error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Get Message Reads ───────────────────────────────────────
+  ipcMain.handle(ch('chat-get-message-reads'), async (event, { conversation_id }) => {
+    try {
+      const rows = await dbQuery(`
+        SELECT r.message_id, r.user_id, u.username, r.read_at
+        FROM chat_message_reads r
+        JOIN chat_users u ON u.id = r.user_id
+        JOIN chat_messages m ON m.id = r.message_id
+        WHERE m.conversation_id = ?
+        ORDER BY r.read_at ASC
+      `, [conversation_id]);
+      return { success: true, data: rows };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-get-message-reads error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Create Team ─────────────────────────────────────────────
+  ipcMain.handle(ch('chat-create-team'), async (event, { current_username, name, member_ids }) => {
+    try {
+      const gk = normalizeUsername(current_username);
+      const me = await dbGetOne('SELECT id FROM chat_users WHERE global_key = ?', [gk]);
+      if (!me) return { success: false, error: 'User not found' };
+      if (!member_ids || member_ids.length < 2) return { success: false, error: 'Need at least 2 members' };
+
+      // Ensure creator is in member list
+      const allMembers = new Set(member_ids.map(Number));
+      allMembers.add(me.id);
+
+      const convResult = await dbQuery(
+        "INSERT INTO chat_conversations (type, name, created_by, created_at, updated_at) VALUES ('team', ?, ?, NOW(), NOW())",
+        [name, me.id]
+      );
+      const convId = convResult.insertId;
+
+      for (const uid of allMembers) {
+        await dbQuery(
+          'INSERT INTO chat_participants (conversation_id, user_id, status, joined_at) VALUES (?, ?, \'active\', NOW())',
+          [convId, uid]
+        );
+      }
+
+      emit('chat:new_conversation', { conversation_id: convId });
+      return { success: true, conversation_id: convId };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-create-team error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Update Team ─────────────────────────────────────────────
+  ipcMain.handle(ch('chat-update-team'), async (event, { conversation_id, name, member_ids, current_username }) => {
+    try {
+      if (name) {
+        await dbQuery('UPDATE chat_conversations SET name = ?, updated_at = NOW() WHERE id = ?', [name, conversation_id]);
+      }
+
+      if (member_ids && member_ids.length > 0) {
+        const gk = normalizeUsername(current_username);
+        const me = await dbGetOne('SELECT id FROM chat_users WHERE global_key = ?', [gk]);
+
+        // Get current active members
+        const current = await dbQuery(
+          "SELECT user_id FROM chat_participants WHERE conversation_id = ? AND status = 'active'",
+          [conversation_id]
+        );
+        const currentIds = new Set(current.map(r => r.user_id));
+        const newIds = new Set(member_ids.map(Number));
+
+        // Remove members not in new list (except self)
+        for (const uid of currentIds) {
+          if (!newIds.has(uid) && me && uid !== me.id) {
+            await dbQuery(
+              "UPDATE chat_participants SET status = 'removed', removed_at = NOW(), removed_by = ? WHERE conversation_id = ? AND user_id = ?",
+              [me ? me.id : null, conversation_id, uid]
+            );
+          }
+        }
+
+        // Add new members
+        for (const uid of newIds) {
+          if (!currentIds.has(uid)) {
+            await dbQuery(
+              'INSERT INTO chat_participants (conversation_id, user_id, status, joined_at) VALUES (?, ?, \'active\', NOW())',
+              [conversation_id, uid]
+            );
+          }
+        }
+      }
+
+      return { success: true };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-update-team error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── Delete Team ─────────────────────────────────────────────
+  ipcMain.handle(ch('chat-delete-team'), async (event, { conversation_id }) => {
+    try {
+      // Delete reads for messages in this conversation
+      await dbQuery(`
+        DELETE r FROM chat_message_reads r
+        JOIN chat_messages m ON m.id = r.message_id
+        WHERE m.conversation_id = ?
+      `, [conversation_id]);
+      await dbQuery('DELETE FROM chat_messages WHERE conversation_id = ?', [conversation_id]);
+      await dbQuery('DELETE FROM chat_participants WHERE conversation_id = ?', [conversation_id]);
+      await dbQuery('DELETE FROM chat_conversations WHERE id = ?', [conversation_id]);
+      return { success: true };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-delete-team error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  // ── List Teams ──────────────────────────────────────────────
+  ipcMain.handle(ch('chat-list-teams'), async () => {
+    try {
+      const rows = await dbQuery(`
+        SELECT c.id, c.name,
+          GROUP_CONCAT(p.user_id) AS member_ids,
+          GROUP_CONCAT(u.username) AS member_usernames
+        FROM chat_conversations c
+        JOIN chat_participants p ON p.conversation_id = c.id AND p.status = 'active'
+        JOIN chat_users u ON u.id = p.user_id
+        WHERE c.type = 'team'
+        GROUP BY c.id, c.name
+      `);
+      return { success: true, data: rows };
+    } catch (err) {
+      console.error('[TacelChatAPI] chat-list-teams error:', err);
+      return { success: false, error: err.message };
+    }
+  });
+
+  console.log(`[TacelChatAPI] Registered chat IPC handlers${prefix ? ` with prefix "${prefix}"` : ''}`);
+}
+
+module.exports = { initChatAPI };

package/chat-sync.js

@@ -0,0 +1,65 @@
+/**
+ * tacel-chat — User sync utility
+ * Registers/updates a user in the shared APP-CHATS database.
+ */
+
+function normalizeUsername(username) {
+  return (username || '').trim().toLowerCase();
+}
+
+/**
+ * Sync a user into the chat_users table
+ * @param {object} options
+ * @param {Function} options.dbQuery - (sql, params) => Promise<Array>
+ * @param {Function} options.dbGetOne - (sql, params) => Promise<object|null>
+ * @param {number|string} options.original_id - User's ID in the app's own DB
+ * @param {string} options.app - App identifier (e.g., 'Office-HQ')
+ * @param {string} options.username - Display name
+ * @returns {Promise<object>} The synced user record
+ */
+async function syncUser({ dbQuery, dbGetOne, original_id, app, username }) {
+  if (!original_id || !app || !username) {
+    throw new Error('syncUser requires original_id, app, username');
+  }
+
+  const global_key = normalizeUsername(username);
+
+  try {
+    // Try to find by global_key first (cross-app unification)
+    let existing = await dbGetOne('SELECT * FROM chat_users WHERE global_key = ?', [global_key]);
+
+    // Fallback to (original_id, app) pair
+    if (!existing) {
+      existing = await dbGetOne(
+        'SELECT * FROM chat_users WHERE original_id = ? AND app = ?',
+        [original_id, app]
+      );
+    }
+
+    if (existing) {
+      // Update existing user
+      await dbQuery(
+        'UPDATE chat_users SET username = ?, global_key = ?, app = ?, original_id = ?, is_online = 1, last_seen = CURRENT_TIMESTAMP, last_active = CURRENT_TIMESTAMP WHERE id = ?',
+        [username, global_key, app, original_id, existing.id]
+      );
+      const updated = await dbGetOne('SELECT * FROM chat_users WHERE id = ?', [existing.id]);
+      console.log(`[ChatSync] Updated existing chat user id=${existing.id}`);
+      return updated || { ...existing, username, global_key, app, original_id };
+    }
+
+    // Create new user
+    const result = await dbQuery(
+      'INSERT INTO chat_users (original_id, app, username, global_key, is_online, last_seen, last_active) VALUES (?, ?, ?, ?, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)',
+      [original_id, app, username, global_key]
+    );
+    const id = result.insertId;
+    const created = await dbGetOne('SELECT * FROM chat_users WHERE id = ?', [id]);
+    console.log(`[ChatSync] Created new chat user id=${id}`);
+    return created || { id, original_id, app, username, global_key };
+  } catch (err) {
+    console.error('[ChatSync] Failed to sync user:', { original_id, app, username, error: err.message });
+    throw err;
+  }
+}
+
+module.exports = { syncUser, normalizeUsername };