@mazees/mark 5.0.0

package/src/server/memory/orama-store.js

@@ -0,0 +1,177 @@
+import { create, insert, insertMultiple, search, remove, removeMultiple } from '@orama/orama'
+import { generateVector, cosineSimilarity } from './vector-engine.js'
+
+const VECTOR_SIZE = 384
+
+let memoryIndex = null
+let archiveIndex = null
+let documentIndex = null
+let turnPairIndex = null
+
+/**
+ * Inisialisasi 4 indeks pencarian Orama di server
+ */
+export async function initOramaIndices() {
+  memoryIndex = await create({
+    schema: {
+      type: 'string',
+      summary: 'string',
+      memory: 'string',
+      timestamp: 'number',
+      dbId: 'string',
+      vector: `vector[${VECTOR_SIZE}]`
+    }
+  })
+
+  archiveIndex = await create({
+    schema: {
+      summary: 'string',
+      topic: 'string',
+      timestamp: 'number',
+      dbId: 'string',
+      vector: `vector[${VECTOR_SIZE}]`
+    }
+  })
+
+  documentIndex = await create({
+    schema: {
+      docName: 'string',
+      chunkIndex: 'number',
+      content: 'string',
+      timestamp: 'number',
+      dbId: 'string',
+      vector: `vector[${VECTOR_SIZE}]`
+    }
+  })
+
+  turnPairIndex = await create({
+    schema: {
+      pairId: 'string',
+      sessionId: 'string',
+      sessionTitle: 'string',
+      userText: 'string',
+      aiText: 'string',
+      combinedText: 'string',
+      timestamp: 'number',
+      vector: `vector[${VECTOR_SIZE}]`
+    }
+  })
+}
+
+/**
+ * Insert atau update item di memoryIndex
+ */
+export async function insertMemoryIndex(item) {
+  if (!memoryIndex) return
+  await insert(memoryIndex, {
+    type: String(item.type || 'profile'),
+    summary: String(item.summary || ''),
+    memory: String(item.memory || item.content || ''),
+    timestamp: Number(item.timestamp) || Date.now(),
+    dbId: String(item.id || ''),
+    vector: item.vector
+  })
+}
+
+/**
+ * Search Memories di Orama
+ */
+export async function searchMemories(queryText, threshold = 0.3, limit = 5) {
+  if (!memoryIndex || !queryText) return []
+  const queryVector = await generateVector(queryText)
+  if (!queryVector) return []
+
+  try {
+    const results = await search(memoryIndex, {
+      mode: 'vector',
+      vector: { value: queryVector, property: 'vector' },
+      similarity: threshold,
+      limit
+    })
+    return results.hits.map((h) => ({ ...h.document, score: h.score }))
+  } catch (_) {
+    return []
+  }
+}
+
+/**
+ * Insert turn pair ke turnPairIndex
+ */
+export async function insertTurnPairIndex(item) {
+  if (!turnPairIndex) return
+  await insert(turnPairIndex, {
+    pairId: String(item.pairId || item.id || ''),
+    sessionId: String(item.sessionId || '1'),
+    sessionTitle: String(item.sessionTitle || 'Session'),
+    userText: String(item.userText || ''),
+    aiText: String(item.aiText || ''),
+    combinedText: String(item.combinedText || `${item.userText} ${item.aiText}`),
+    timestamp: Number(item.timestamp) || Date.now(),
+    vector: item.vector
+  })
+}
+
+/**
+ * Search Turn Pairs di Orama
+ */
+export async function searchTurnPairs(queryText, threshold = 0.35, limit = 4) {
+  if (!turnPairIndex || !queryText) return []
+  const queryVector = await generateVector(queryText)
+  if (!queryVector) return []
+
+  try {
+    const results = await search(turnPairIndex, {
+      mode: 'vector',
+      vector: { value: queryVector, property: 'vector' },
+      similarity: threshold,
+      limit
+    })
+    return results.hits.map((h) => ({ ...h.document, score: h.score }))
+  } catch (_) {
+    return []
+  }
+}
+
+/**
+ * Search Archives di Orama
+ */
+export async function searchArchives(queryText, threshold = 0.3, limit = 3) {
+  if (!archiveIndex || !queryText) return []
+  const queryVector = await generateVector(queryText)
+  if (!queryVector) return []
+
+  try {
+    const results = await search(archiveIndex, {
+      mode: 'vector',
+      vector: { value: queryVector, property: 'vector' },
+      similarity: threshold,
+      limit
+    })
+    return results.hits.map((h) => ({ ...h.document, score: h.score }))
+  } catch (_) {
+    return []
+  }
+}
+
+/**
+ * Search Documents (RAG) di Orama
+ */
+export async function searchDocuments(queryText, threshold = 0.3, limit = 4) {
+  if (!documentIndex || !queryText) return []
+  const queryVector = await generateVector(queryText)
+  if (!queryVector) return []
+
+  try {
+    const results = await search(documentIndex, {
+      mode: 'vector',
+      vector: { value: queryVector, property: 'vector' },
+      similarity: threshold,
+      limit
+    })
+    return results.hits.map((h) => ({ ...h.document, score: h.score }))
+  } catch (_) {
+    return []
+  }
+}
+
+export { memoryIndex, archiveIndex, documentIndex, turnPairIndex, insertMultiple }

package/src/server/memory/vector-engine.js

@@ -0,0 +1,109 @@
+import path from 'path'
+import os from 'os'
+import fs from 'fs'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
+const { pipeline, env } = require('@huggingface/transformers')
+
+// Konfigurasi cache direktori lokal persisten
+const CACHE_DIR = path.join(os.homedir(), '.cache', 'mark-transformers')
+if (!fs.existsSync(CACHE_DIR)) {
+  fs.mkdirSync(CACHE_DIR, { recursive: true })
+}
+
+env.cacheDir = CACHE_DIR
+env.allowLocalModels = true
+env.allowRemoteModels = true
+
+let extractor = null
+let isInitializing = false
+const initWaiters = []
+
+/**
+ * Inisialisasi pipeline feature-extraction MiniLM-L12-v2 secara lokal
+ */
+export async function getExtractor() {
+  if (extractor) return extractor
+  if (isInitializing) {
+    return new Promise((resolve) => initWaiters.push(resolve))
+  }
+
+  isInitializing = true
+
+  try {
+    extractor = await pipeline(
+      'feature-extraction',
+      'Xenova/paraphrase-multilingual-MiniLM-L12-v2',
+      {
+        quantized: true
+      }
+    )
+    isInitializing = false
+    initWaiters.forEach((resolve) => resolve(extractor))
+    initWaiters.length = 0
+    return extractor
+  } catch (err) {
+    isInitializing = false
+    initWaiters.forEach((resolve) => resolve(null))
+    initWaiters.length = 0
+    return null
+  }
+}
+
+/**
+ * Menghasilkan vektor 384 dimensi untuk suatu teks
+ * @param {string} text
+ * @returns {Promise<number[]|null>}
+ */
+export async function generateVector(text) {
+  if (!text || typeof text !== 'string' || !text.trim()) return null
+  const clean = text.trim().slice(0, 1000)
+
+  try {
+    const ext = await getExtractor()
+    if (!ext) return null
+
+    const output = await ext(clean, { pooling: 'mean', normalize: true })
+    return Array.from(output.data)
+  } catch (_) {
+    return null
+  }
+}
+
+/**
+ * Menghasilkan vektor batch untuk beberapa teks sekaligus
+ * @param {Array<{id: any, text: string}>} items
+ * @returns {Promise<Array<{id: any, vector: number[]|null}>>}
+ */
+export async function generateVectorBatch(items) {
+  if (!Array.isArray(items) || items.length === 0) return []
+  const results = []
+
+  for (const item of items) {
+    const vector = await generateVector(item.text)
+    results.push({ id: item.id, vector })
+  }
+
+  return results
+}
+
+/**
+ * Menghitung cosine similarity antara 2 vektor
+ * @param {number[]} vecA
+ * @param {number[]} vecB
+ * @returns {number}
+ */
+export function cosineSimilarity(vecA, vecB) {
+  if (!vecA || !vecB || vecA.length !== vecB.length) return 0
+  let dotProduct = 0
+  let normA = 0
+  let normB = 0
+  for (let i = 0; i < vecA.length; i++) {
+    dotProduct += vecA[i] * vecB[i]
+    normA += vecA[i] * vecA[i]
+    normB += vecB[i] * vecB[i]
+  }
+  if (normA === 0 || normB === 0) return 0
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB))
+}

package/src/server/routes/ai.routes.js

@@ -0,0 +1,280 @@
+import { Router } from 'express'
+import { getActiveConfig } from '../config-manager.js'
+import { wsHub } from '../ws-hub.js'
+import { launchUI } from '../launcher.js'
+import {
+  GROUP_TOOLS_SCHEMA,
+  GROUP_TOOL_GROUP_NAMES,
+  GROUP_TOOLS_DEFINITION,
+  group_tools_flat
+} from '../tools/group-tools.js'
+
+export const aiRouter = Router()
+
+// 1. AI Fetch Direct Gateway
+aiRouter.post('/ai/fetch', async (req, res) => {
+  const {
+    messages,
+    config = {},
+    isSmallTask = false,
+    jsonSchema = null,
+    sessionId = null
+  } = req.body || {}
+  try {
+    const { fetchAI } = await import('../services/ai-bridge.js')
+    const finalConfig = { ...getActiveConfig(), ...config }
+    const provider = finalConfig.aiProvider || 'gemini-web'
+    const resolvedModel =
+      provider === 'gemini-web'
+        ? finalConfig.geminiWebModel || 'gemini-3.6-flash'
+        : provider === 'deepseek-web'
+          ? finalConfig.deepseekWebModel || 'deepseek-chat'
+          : provider === 'custom'
+            ? finalConfig.customModel || 'default-model'
+            : finalConfig.model || 'local-model'
+
+    wsHub.broadcast('ai:fetch', {
+      type: 'fetch',
+      provider,
+      model: resolvedModel,
+      messagesCount: Array.isArray(messages) ? messages.length : 0,
+      hasTools: false
+    })
+
+    const result = await fetchAI(messages, false, {
+      config: finalConfig,
+      isSmallTask,
+      jsonSchema,
+      sessionId
+    })
+    res.json(result)
+  } catch (err) {
+    res.status(500).json({ error: { message: err.message, code: err.code || 'AI_ERROR' } })
+  }
+})
+
+// 2. AI Streaming Gateway (Native Tool Calling + SSE & WebSocket Tokens)
+aiRouter.post('/ai/stream', async (req, res) => {
+  const {
+    messages,
+    tools = null,
+    config = {},
+    isSmallTask = false,
+    sessionId = null
+  } = req.body || {}
+  try {
+    const { fetchAI } = await import('../services/ai-bridge.js')
+    const finalConfig = { ...getActiveConfig(), ...config }
+    const provider = finalConfig.aiProvider || 'gemini-web'
+    const resolvedModel =
+      provider === 'gemini-web'
+        ? finalConfig.geminiWebModel || 'gemini-3.6-flash'
+        : provider === 'deepseek-web'
+          ? finalConfig.deepseekWebModel || 'deepseek-chat'
+          : provider === 'custom'
+            ? finalConfig.customModel || 'default-model'
+            : finalConfig.model || 'local-model'
+
+    wsHub.broadcast('ai:fetch', {
+      type: 'stream',
+      provider,
+      model: resolvedModel,
+      messagesCount: Array.isArray(messages) ? messages.length : 0,
+      hasTools: Array.isArray(tools) && tools.length > 0,
+      toolsCount: Array.isArray(tools) ? tools.length : 0
+    })
+
+    const result = await fetchAI(messages, true, {
+      tools,
+      config: finalConfig,
+      isSmallTask,
+      sessionId,
+      onToken: (token) => {
+        wsHub.streamToken(token, 'answer')
+      },
+      onReasoning: (rToken) => {
+        wsHub.streamToken(rToken, 'thought')
+      },
+      onMood: (mood) => {
+        wsHub.broadcast('ai:mood', { mood })
+      },
+      onMeta: (meta) => {
+        wsHub.broadcast('ai:mark_meta', meta)
+        if (meta?.mood) {
+          wsHub.broadcast('ai:mood', { mood: meta.mood })
+        }
+      },
+      onToolCall: (toolCalls) => {
+        wsHub.broadcast('ai:tool_calls', { toolCalls })
+      }
+    })
+
+    res.json(result)
+  } catch (err) {
+    res.status(500).json({ error: { message: err.message, code: err.code || 'AI_ERROR' } })
+  }
+})
+
+aiRouter.post('/ai/abort', async (req, res) => {
+  try {
+    const { abortAllFetches } = await import('../services/ai-bridge.js')
+    abortAllFetches()
+    res.json({ success: true })
+  } catch (err) {
+    res.json({ success: false, error: err.message })
+  }
+})
+
+aiRouter.post('/ai/reset-session', async (req, res) => {
+  try {
+    const { clearDeepSeekSession } = await import('../services/deepseek-web.js')
+    clearDeepSeekSession()
+    res.json({ success: true })
+  } catch (err) {
+    res.json({ success: false, error: err.message })
+  }
+})
+
+// 3. Group Tools Schema & Registry API
+aiRouter.get('/tools/groups', (_req, res) => {
+  res.json({
+    success: true,
+    data: {
+      schema: GROUP_TOOLS_SCHEMA,
+      names: GROUP_TOOL_GROUP_NAMES,
+      definition: GROUP_TOOLS_DEFINITION,
+      flat: group_tools_flat
+    }
+  })
+})
+
+// 4. Native Tools Execution API
+aiRouter.post('/tools/execute', async (req, res) => {
+  const { tool, query, config } = req.body || {}
+  try {
+    if (typeof tool === 'string' && tool.startsWith('plugin-')) {
+      const { executePluginAction } = await import('../../main/plugins/plugin-loader.js')
+      const result = await executePluginAction(tool, query)
+      return res.json(result)
+    }
+    const { NATIVE_TOOLS } = await import('../../main/node-tools.js')
+    const nativeTool = NATIVE_TOOLS[tool]
+    if (!nativeTool) {
+      return res.json({ success: false, error: `Tool '${tool}' tidak ditemukan` })
+    }
+    const finalConfig = config || getActiveConfig()
+    const result = await nativeTool.handler(query, finalConfig)
+    if (result && typeof result === 'object' && 'success' in result) {
+      return res.json(result)
+    }
+    res.json({ success: true, data: result })
+  } catch (err) {
+    res.json({ success: false, error: err.message })
+  }
+})
+
+aiRouter.post('/tools/needs-approval', async (req, res) => {
+  const { tool, query } = req.body || {}
+  try {
+    const { NATIVE_TOOLS } = await import('../../main/node-tools.js')
+    const nativeTool = NATIVE_TOOLS[tool]
+    if (!nativeTool) return res.json({ needsApproval: false })
+    const needs =
+      typeof nativeTool.needsApproval === 'function'
+        ? nativeTool.needsApproval(query)
+        : nativeTool.needsApproval
+    res.json({
+      needsApproval: Boolean(needs),
+      message: needs && nativeTool.approvalMessage ? nativeTool.approvalMessage(query) : null
+    })
+  } catch {
+    res.json({ needsApproval: false })
+  }
+})
+
+// 4. Edge-TTS Speech Synthesis API
+aiRouter.get('/tts/stream', async (req, res) => {
+  const { text, voice, rate = 10, pitch = 55 } = req.query || {}
+  try {
+    const { streamTTS } = await import('../tools/media-tools.js')
+    const audioStream = await streamTTS(text, voice, rate, pitch)
+    res.setHeader('Content-Type', 'audio/mpeg')
+    res.setHeader('Transfer-Encoding', 'chunked')
+    res.setHeader('Cache-Control', 'no-cache, no-store')
+    res.setHeader('Access-Control-Allow-Origin', '*')
+
+    req.on('close', () => {
+      if (!audioStream.destroyed) {
+        audioStream.destroy()
+      }
+    })
+
+    audioStream.on('error', (err) => {
+      if (!res.headersSent) {
+        res.status(500).json({ success: false, error: err.message })
+      } else {
+        res.end()
+      }
+    })
+
+    audioStream.pipe(res)
+  } catch (err) {
+    if (!res.headersSent) {
+      res.status(500).json({ success: false, error: err.message })
+    }
+  }
+})
+
+aiRouter.post('/tts/stream', async (req, res) => {
+  const { text, voice, rate = 0, pitch = 0 } = req.body || {}
+  try {
+    const { streamTTS } = await import('../tools/media-tools.js')
+    const audioStream = await streamTTS(text, voice, rate, pitch)
+    res.setHeader('Content-Type', 'audio/mpeg')
+    res.setHeader('Transfer-Encoding', 'chunked')
+    res.setHeader('Cache-Control', 'no-cache, no-store')
+    res.setHeader('Access-Control-Allow-Origin', '*')
+
+    req.on('close', () => {
+      if (!audioStream.destroyed) {
+        audioStream.destroy()
+      }
+    })
+
+    audioStream.on('error', (err) => {
+      if (!res.headersSent) {
+        res.status(500).json({ success: false, error: err.message })
+      } else {
+        res.end()
+      }
+    })
+
+    audioStream.pipe(res)
+  } catch (err) {
+    if (!res.headersSent) {
+      res.status(500).json({ success: false, error: err.message })
+    }
+  }
+})
+
+aiRouter.post('/tts', async (req, res) => {
+  const { text, voice, rate = 0, pitch = 0 } = req.body || {}
+  try {
+    const { synthesizeTTS } = await import('../tools/media-tools.js')
+    const result = await synthesizeTTS(text, voice, rate, pitch)
+    res.json({ success: true, ...result })
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})
+
+// 5. Launcher API
+aiRouter.post('/launcher/open', async (req, res) => {
+  const { mode = 'app', port = 3000 } = req.body || {}
+  try {
+    await launchUI({ port: req.app.get('port') || port, mode })
+    res.json({ success: true, message: `Launcher triggered for mode: ${mode}` })
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})

package/src/server/routes/awareness.routes.js

@@ -0,0 +1,62 @@
+import { Router } from 'express'
+import {
+  getActivityBuffer,
+  clearActivityBuffer,
+  getSystemIdleSeconds,
+  getSystemTelemetry
+} from '../tools/awareness-tracker.js'
+import { captureDesktopScreenshotsBase64 } from '../tools/screen-service.js'
+
+export const awarenessRouter = Router()
+
+awarenessRouter.get('/awareness/activity-buffer', async (_req, res) => {
+  try {
+    const telemetry = await getSystemTelemetry()
+    res.json({ success: true, data: getActivityBuffer(), telemetry })
+  } catch {
+    res.json({ success: true, data: getActivityBuffer(), telemetry: null })
+  }
+})
+
+awarenessRouter.get('/awareness/telemetry', async (_req, res) => {
+  try {
+    const telemetry = await getSystemTelemetry()
+    res.json({ success: true, telemetry })
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})
+
+awarenessRouter.post('/awareness/clear-buffer', (_req, res) => {
+  clearActivityBuffer()
+  res.json({ success: true })
+})
+
+awarenessRouter.get('/awareness/idle-time', async (_req, res) => {
+  try {
+    const idleSeconds = await getSystemIdleSeconds()
+    res.json({ success: true, idleSeconds })
+  } catch {
+    res.json({ success: true, idleSeconds: 0 })
+  }
+})
+
+awarenessRouter.post('/os/screenshot', async (_req, res) => {
+  try {
+    const screens = await captureDesktopScreenshotsBase64()
+    res.json({ success: true, data: screens })
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})
+
+awarenessRouter.post('/system/notify', async (req, res) => {
+  const { title = 'Mark', body = '' } = req.body || {}
+  try {
+    const { showNativeNotification } = await import('../services/notification-service.js')
+    showNativeNotification(title, body)
+    res.json({ success: true })
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})

package/src/server/routes/chat.routes.js

@@ -0,0 +1,61 @@
+import { Router } from 'express'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { fetchAI } from '../services/ai-bridge.js'
+import { getActiveConfig } from '../config-manager.js'
+
+export const chatRouter = Router()
+
+chatRouter.post('/chat/upload-temp', async (req, res) => {
+  const { fileName, dataUrl, base64Data } = req.body || {}
+  try {
+    const rawBase64 = base64Data || (dataUrl ? dataUrl.replace(/^data:[^;]+;base64,/, '') : null)
+    if (!rawBase64) {
+      return res.status(400).json({ success: false, error: 'Data base64 kosong' })
+    }
+    const tempDir = path.join(os.homedir(), '.config', 'mark-agent', 'temp-uploads')
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true })
+    }
+    const safeName = (fileName || `image-${Date.now()}.png`).replace(/[^a-zA-Z0-9_.-]/g, '_')
+    const finalName = `${Date.now()}-${safeName}`
+    const targetPath = path.join(tempDir, finalName)
+    const buffer = Buffer.from(rawBase64, 'base64')
+    await fs.promises.writeFile(targetPath, buffer)
+
+    res.json({
+      success: true,
+      path: targetPath,
+      name: finalName,
+      url: `/api/chat/temp-file/${encodeURIComponent(finalName)}`,
+      size: buffer.length
+    })
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})
+
+chatRouter.get('/chat/temp-file/:fileName', (req, res) => {
+  try {
+    const safeName = path.basename(req.params.fileName)
+    const filePath = path.join(os.homedir(), '.config', 'mark-agent', 'temp-uploads', safeName)
+    if (fs.existsSync(filePath)) {
+      return res.sendFile(filePath)
+    }
+    res.status(404).send('File tidak ditemukan')
+  } catch (err) {
+    res.status(500).send(err.message)
+  }
+})
+
+chatRouter.post('/chat', async (req, res) => {
+  const { message, messages } = req.body || {}
+  const effectiveMessages = messages || [{ role: 'user', content: message || '' }]
+  try {
+    const result = await fetchAI(effectiveMessages, false, { config: getActiveConfig() })
+    res.json(result)
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})