@mazees/mark 5.0.0

package/src/server/services/gemini-web.js

@@ -0,0 +1,170 @@
+/**
+ * Gemini Web RPC Engine for MARK Node.js Core
+ */
+import https from 'https'
+import crypto from 'crypto'
+
+export const GEMINI_WEB_MODELS = {
+  'gemini-3.6-flash': {
+    mode: 1,
+    think: 4,
+    name: 'gemini-3.6-flash',
+    desc: 'Model utama serbaguna versi terbaru'
+  },
+  'gemini-3.5-flash': {
+    mode: 1,
+    think: 4,
+    name: 'gemini-3.5-flash',
+    desc: 'Model Flash seimbang dan stabil'
+  },
+  'gemini-3.5-flash-thinking': {
+    mode: 2,
+    think: 0,
+    name: 'gemini-3.5-flash-thinking',
+    desc: 'Mode penalaran mendalam untuk analisis rumit'
+  },
+  'gemini-3.5-flash-thinking-lite': {
+    mode: 5,
+    think: 0,
+    name: 'gemini-3.5-flash-thinking-lite',
+    desc: 'Mode penalaran cepat dengan kedalaman fleksibel'
+  },
+  'gemini-auto': {
+    mode: 4,
+    think: 4,
+    name: 'gemini-auto',
+    desc: 'Penyesuaian model otomatis oleh server'
+  },
+  'gemini-flash-lite': {
+    mode: 6,
+    think: 4,
+    name: 'gemini-flash-lite',
+    desc: 'Model super ringan dengan respon instan'
+  }
+}
+
+const DEFAULT_BL = 'boq_assistant-bard-web-server_20260730.01_p1'
+
+function httpPost(urlStr, headers, bodyData) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(urlStr)
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || 443,
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: 'POST',
+      headers: headers
+    }
+    const req = https.request(options, (res) => {
+      let data = ''
+      res.on('data', (chunk) => (data += chunk.toString()))
+      res.on('end', () => resolve(data))
+    })
+    req.on('error', (err) => reject(err))
+    req.write(bodyData)
+    req.end()
+  })
+}
+
+function findRc(arr) {
+  if (!Array.isArray(arr)) return null
+  if (arr[0] && typeof arr[0] === 'string' && arr[0].startsWith('rc_')) {
+    return arr[1][0]
+  }
+  for (const item of arr) {
+    const res = findRc(item)
+    if (res) return res
+  }
+  return null
+}
+
+export async function generateGeminiResponse(
+  prompt,
+  modelName = 'gemini-3.6-flash',
+  cookie = '',
+  bl = DEFAULT_BL
+) {
+  const reqModel = (modelName || 'gemini-3.6-flash').toLowerCase()
+
+  let selected = GEMINI_WEB_MODELS[reqModel]
+  if (!selected) {
+    if (reqModel.includes('thinking-lite')) selected = GEMINI_WEB_MODELS['gemini-3.5-flash-thinking-lite']
+    else if (reqModel.includes('think')) selected = GEMINI_WEB_MODELS['gemini-3.5-flash-thinking']
+    else if (reqModel.includes('auto')) selected = GEMINI_WEB_MODELS['gemini-auto']
+    else if (reqModel.includes('lite') || reqModel.includes('fast')) selected = GEMINI_WEB_MODELS['gemini-flash-lite']
+    else selected = GEMINI_WEB_MODELS['gemini-3.6-flash']
+  }
+
+  const modelId = selected.mode
+  const thinkMode = selected.think
+
+  const inner = new Array(80).fill(null)
+  inner[0] = [prompt, 0, null, null, null, null, 0]
+  inner[1] = ['en']
+  inner[2] = ['', '', '', null, null, null, null, null, null, '']
+  inner[6] = [0]
+  inner[7] = 1
+  inner[10] = 1
+  inner[11] = 0
+  inner[17] = [[thinkMode]]
+  inner[18] = 0
+  inner[27] = 1
+  inner[30] = [4]
+  inner[41] = [2]
+  inner[53] = 0
+  inner[59] = crypto.randomUUID
+    ? crypto.randomUUID()
+    : Math.random().toString(36).substring(2) + Date.now().toString(36)
+  inner[61] = []
+  inner[68] = 1
+  inner[79] = modelId
+
+  const outer = [null, JSON.stringify(inner)]
+  const bodyParams = new URLSearchParams()
+  bodyParams.set('f.req', JSON.stringify(outer))
+
+  const reqid = Math.floor(Date.now() / 1000) % 1000000
+  const url = `https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate?bl=${bl}&hl=id&_reqid=${reqid}&rt=c`
+
+  const headers = {
+    'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
+    accept: '*/*',
+    'x-same-domain': '1',
+    'user-agent':
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36',
+    referer: 'https://gemini.google.com/'
+  }
+
+  if (cookie) {
+    headers['cookie'] = cookie
+  }
+
+  const rawText = await httpPost(url, headers, bodyParams.toString())
+
+  let finalAnswer = ''
+  const lines = rawText.split('\n')
+  for (const line of lines) {
+    if (line.trim().startsWith('[["wrb.fr"')) {
+      try {
+        const parsed = JSON.parse(line.trim())
+        const innerStr = parsed[0][2]
+        if (innerStr) {
+          const innerParsed = JSON.parse(innerStr)
+          const text = findRc(innerParsed)
+          if (text && text.length > finalAnswer.length) {
+            finalAnswer = text
+          }
+        }
+      } catch (e) {}
+    }
+  }
+
+  if (!finalAnswer) {
+    if (rawText.includes('BardErrorInfo')) {
+      throw new Error('Google menolak request (Session / Cookie mungkin expired atau terblokir).')
+    }
+    throw new Error('Gagal mengekstrak jawaban dari Gemini Web. Balasan mentah: ' + rawText.substring(0, 200))
+  }
+
+  return finalAnswer
+}

package/src/server/services/notification-service.js

@@ -0,0 +1,91 @@
+import { exec } from 'child_process'
+import os from 'os'
+import path from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+import { stripMarkTags } from '../../shared/parsers/mark-tag-parser.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * Mendapatkan absolute path icon MARK untuk Windows Toast
+ */
+function getNotificationIconPath() {
+  const candidates = [
+    path.resolve(__dirname, '../../../src/renderer/public/icon-256.png'),
+    path.resolve(__dirname, '../../renderer/public/icon-256.png'),
+    path.resolve(__dirname, '../../../out/renderer/icon-256.png'),
+    path.resolve(__dirname, '../../out/renderer/icon-256.png')
+  ]
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c
+  }
+  return null
+}
+
+/**
+ * Menampilkan notifikasi desktop native Windows (Toast Notification) tanpa izin WebUI.
+ * Menggunakan Windows Runtime (WinRT) PowerShell yang terintegrasi langsung dengan Action Center Windows 10/11
+ * dan menampilkan logo MARK secara native di samping teks.
+ */
+export function showNativeNotification(title = 'Mark', body = '') {
+  const isWindows = os.platform() === 'win32'
+  const safeTitle = stripMarkTags(title || 'Mark')
+    .replace(/["`$\\]/g, ' ')
+    .trim()
+  const safeBody = stripMarkTags(body || '')
+    .replace(/["`$\\]/g, ' ')
+    .trim()
+  const iconPath = getNotificationIconPath()
+
+  if (!isWindows) {
+    if (os.platform() === 'darwin') {
+      exec(`osascript -e 'display notification "${safeBody}" with title "${safeTitle}"'`)
+    } else {
+      const iconArg = iconPath ? `-i "${iconPath}"` : ''
+      exec(`notify-send ${iconArg} "${safeTitle}" "${safeBody}"`)
+    }
+    return
+  }
+
+  // Windows Toast Notification via PowerShell WindowsRuntime dengan icon & app id
+  const hasIcon = Boolean(iconPath && fs.existsSync(iconPath))
+  const templateType = hasIcon ? 'ToastImageAndText02' : 'ToastText02'
+  const formattedIconUri = hasIcon ? 'file:///' + iconPath.replace(/\\/g, '/') : ''
+
+  const psScript = `
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
+$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::${templateType})
+
+${
+  hasIcon
+    ? `
+$imageNodes = $template.GetElementsByTagName("image")
+$imageNodes.Item(0).Attributes.GetNamedItem("src").NodeValue = "${formattedIconUri}"
+`
+    : ''
+}
+
+$textNodes = $template.GetElementsByTagName("text")
+$textNodes.Item(0).AppendChild($template.CreateTextNode("${safeTitle}")) | Out-Null
+$textNodes.Item(1).AppendChild($template.CreateTextNode("${safeBody}")) | Out-Null
+
+$toast = [Windows.UI.Notifications.ToastNotification]::new($template)
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("MARK Agent").Show($toast)
+`.trim()
+
+  const encodedCommand = Buffer.from(psScript, 'utf16le').toString('base64')
+  exec(
+    `powershell.exe -NoProfile -ExecutionPolicy Bypass -EncodedCommand ${encodedCommand}`,
+    {
+      windowsHide: true
+    },
+    (err) => {
+      if (err) {
+        console.warn('[notification-service] Gagal memicu Windows Toast:', err.message)
+      }
+    }
+  )
+}

package/src/server/services/updater.js

@@ -0,0 +1,125 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export const PACKAGE_NAME = '@mazees/mark'
+const CACHE_FILE = path.join(os.homedir(), '.config', 'mark-agent', 'update-cache.json')
+const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000 // 6 jam
+
+let currentPackageVersion = '5.0.0'
+try {
+  const pkgPath = path.resolve(__dirname, '../../../package.json')
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+    if (pkg.version) currentPackageVersion = pkg.version
+  }
+} catch (_) {}
+
+export function getCurrentVersion() {
+  return currentPackageVersion
+}
+
+export function getUpdateInstruction() {
+  return `npm install -g ${PACKAGE_NAME}@latest`
+}
+
+export function parseSemver(v) {
+  if (!v) return [0, 0, 0]
+  return String(v)
+    .replace(/^v/, '')
+    .split('.')
+    .map((n) => parseInt(n, 10) || 0)
+}
+
+export function isNewerVersion(latest, current) {
+  if (!latest || !current) return false
+  const [lMaj, lMin, lPat] = parseSemver(latest)
+  const [cMaj, cMin, cPat] = parseSemver(current)
+  if (lMaj > cMaj) return true
+  if (lMaj < cMaj) return false
+  if (lMin > cMin) return true
+  if (lMin < cMin) return false
+  return lPat > cPat
+}
+
+export async function checkForUpdate(options = {}) {
+  const { force = false } = options
+  const currentVersion = getCurrentVersion()
+
+  // 1. Dukungan Mock untuk Testing Lokal (sebelum rilis resmi di registry npm)
+  if (process.env.MARK_MOCK_LATEST_VERSION) {
+    const mockVersion = process.env.MARK_MOCK_LATEST_VERSION.trim()
+    return {
+      hasUpdate: isNewerVersion(mockVersion, currentVersion),
+      latestVersion: mockVersion,
+      currentVersion,
+      instruction: getUpdateInstruction(),
+      isMock: true
+    }
+  }
+
+  // 2. Periksa Cache Lokal
+  if (!force && fs.existsSync(CACHE_FILE)) {
+    try {
+      const cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'))
+      if (Date.now() - (cache.lastChecked || 0) < CHECK_INTERVAL_MS) {
+        return {
+          hasUpdate: isNewerVersion(cache.latestVersion, currentVersion),
+          latestVersion: cache.latestVersion,
+          currentVersion,
+          instruction: getUpdateInstruction(),
+          cached: true
+        }
+      }
+    } catch (_) {}
+  }
+
+  // 3. Query Registry NPM (timeout 2500ms agar non-blocking)
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      headers: { Accept: 'application/json' },
+      signal: AbortSignal.timeout(2500)
+    })
+
+    if (!res.ok) {
+      return {
+        hasUpdate: false,
+        latestVersion: currentVersion,
+        currentVersion,
+        instruction: getUpdateInstruction()
+      }
+    }
+
+    const data = await res.json()
+    const latestVersion = data.version || currentVersion
+
+    // 4. Simpan ke Cache Lokal
+    try {
+      fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true })
+      fs.writeFileSync(
+        CACHE_FILE,
+        JSON.stringify({ lastChecked: Date.now(), latestVersion }, null, 2),
+        'utf8'
+      )
+    } catch (_) {}
+
+    return {
+      hasUpdate: isNewerVersion(latestVersion, currentVersion),
+      latestVersion,
+      currentVersion,
+      instruction: getUpdateInstruction()
+    }
+  } catch (_) {
+    // Gagal fetch (offline, DNS timeout, dll) -> gracefully return false
+    return {
+      hasUpdate: false,
+      latestVersion: currentVersion,
+      currentVersion,
+      instruction: getUpdateInstruction()
+    }
+  }
+}

package/src/server/tools/awareness-tracker.js

@@ -0,0 +1,292 @@
+import activeWin from 'active-win'
+import { exec } from 'child_process'
+import util from 'util'
+import os from 'os'
+import { wsHub } from '../ws-hub.js'
+import { isDaemonAlive, startDaemon, sendCommand } from './pc-agent.js'
+import { getActiveConfig } from '../config-manager.js'
+
+const execPromise = util.promisify(exec)
+
+const activityBuffer = []
+const MAX_BUFFER_SIZE = 30
+let trackerInterval = null
+
+let currentActiveApp = null
+let currentActiveTitle = null
+let currentAppStartTime = Date.now()
+
+let lastCpuSample = null
+let cachedCpuPercent = 0
+let cachedBattery = { hasBattery: false, percent: 100, isCharging: true }
+let lastBatteryFetch = 0
+
+function sampleCpuPercent() {
+  const cpus = os.cpus()
+  if (!cpus || cpus.length === 0) return 0
+  let user = 0
+  let nice = 0
+  let sys = 0
+  let idle = 0
+  let irq = 0
+  for (const cpu of cpus) {
+    user += cpu.times.user
+    nice += cpu.times.nice
+    sys += cpu.times.sys
+    idle += cpu.times.idle
+    irq += cpu.times.irq
+  }
+  const currentSample = { idle, total: user + nice + sys + idle + irq }
+  if (lastCpuSample) {
+    const idleDelta = currentSample.idle - lastCpuSample.idle
+    const totalDelta = currentSample.total - lastCpuSample.total
+    if (totalDelta > 0) {
+      cachedCpuPercent = Math.max(0, Math.min(100, Math.round((1 - idleDelta / totalDelta) * 100)))
+    }
+  }
+  lastCpuSample = currentSample
+  return cachedCpuPercent
+}
+
+async function getBatteryTelemetry() {
+  const now = Date.now()
+  if (now - lastBatteryFetch < 60000 && lastBatteryFetch > 0) {
+    return cachedBattery
+  }
+  lastBatteryFetch = now
+  if (process.platform !== 'win32') return cachedBattery
+
+  try {
+    const { stdout } = await execPromise(
+      'powershell -NoProfile -NonInteractive -Command "Get-CimInstance Win32_Battery | Select-Object -Property EstimatedChargeRemaining, BatteryStatus | ConvertTo-Json"'
+    )
+    const text = stdout ? stdout.trim() : ''
+    if (text && text.startsWith('{')) {
+      const parsed = JSON.parse(text)
+      const percent = Number(parsed.EstimatedChargeRemaining ?? 100)
+      const isCharging = [2, 6, 7, 8, 3].includes(parsed.BatteryStatus)
+      cachedBattery = {
+        hasBattery: true,
+        percent,
+        isCharging,
+        status: parsed.BatteryStatus
+      }
+    } else if (text && text.startsWith('[')) {
+      const arr = JSON.parse(text)
+      const parsed = arr[0] || {}
+      cachedBattery = {
+        hasBattery: true,
+        percent: Number(parsed.EstimatedChargeRemaining ?? 100),
+        isCharging: [2, 6, 7, 8, 3].includes(parsed.BatteryStatus),
+        status: parsed.BatteryStatus
+      }
+    }
+  } catch {
+    cachedBattery = { hasBattery: false, percent: 100, isCharging: true }
+  }
+  return cachedBattery
+}
+
+export function recordActivityEntry(winData) {
+  if (!winData || !winData.title) return
+
+  const appName = winData.owner?.name || winData.app || 'System'
+  const title = winData.title.trim()
+
+  if (currentActiveApp !== appName || currentActiveTitle !== title) {
+    currentActiveApp = appName
+    currentActiveTitle = title
+    currentAppStartTime = Date.now()
+  }
+
+  if (
+    activityBuffer.length > 0 &&
+    activityBuffer[0].title === title &&
+    activityBuffer[0].app === appName
+  ) {
+    return
+  }
+
+  const timeStr = new Date().toLocaleTimeString('id-ID', {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  })
+
+  activityBuffer.unshift({
+    app: appName,
+    title: title,
+    url: winData.url || null,
+    timestamp: timeStr,
+    time: timeStr
+  })
+
+  wsHub.broadcast('awareness:entry', { app: appName, title, time: timeStr })
+
+  if (activityBuffer.length > MAX_BUFFER_SIZE) {
+    activityBuffer.pop()
+  }
+}
+
+async function getActiveWindowFallback() {
+  // 1. Coba persistent Win32 PC-Daemon tercepat jika aktif (<1ms, tanpa spawn proses)
+  if (process.platform === 'win32' && isDaemonAlive()) {
+    try {
+      const raw = await sendCommand({ cmd: 'get-active-window' })
+      const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw
+      if (parsed && parsed.title && parsed.title.trim()) {
+        return {
+          title: parsed.title.trim(),
+          owner: { name: parsed.process || 'Windows App' },
+          app: parsed.process || 'Windows App',
+          url: null
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // 2. Coba activeWin native binding sebagai fallback (macOS / Linux / jika tersedia)
+  try {
+    const win = await activeWin()
+    if (win && win.title && win.title.trim()) {
+      return {
+        title: win.title.trim(),
+        owner: { name: win.owner?.name || win.app || 'System' },
+        app: win.owner?.name || win.app || 'System',
+        url: win.url || null
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  // 3. Jika di Windows dan daemon belum aktif, jalankan daemon di background
+  if (process.platform === 'win32' && !isDaemonAlive()) {
+    startDaemon().catch(() => {})
+  }
+
+  return null
+}
+
+export async function getSystemIdleSeconds() {
+  if (process.platform !== 'win32') return 0
+
+  // 1. Prioritaskan Win32 PC-Daemon instan (<0.1ms tanpa spawn PowerShell atau csc.exe)
+  if (isDaemonAlive()) {
+    try {
+      const raw = await sendCommand({ cmd: 'get-idle' })
+      const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw
+      if (parsed && typeof parsed.idleSeconds === 'number') {
+        return parsed.idleSeconds
+      }
+    } catch {
+      // fallback jika daemon sibuk
+    }
+  }
+
+  // 2. Fallback jika daemon belum siap (jalankan daemon untuk panggilan berikutnya)
+  startDaemon().catch(() => {})
+
+  try {
+    const psScript = `
+      $signature = @'
+      [DllImport("user32.dll")]
+      public static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);
+      [StructLayout(LayoutKind.Sequential)]
+      public struct LASTINPUTINFO {
+          public uint cbSize;
+          public uint dwTime;
+      }
+'@
+      $type = Add-Type -MemberDefinition $signature -Name Win32GetLastInput -Namespace Win32API -PassThru
+      $info = New-Object Win32API.Win32GetLastInput+LASTINPUTINFO
+      $info.cbSize = [System.Runtime.InteropServices.Marshal]::SizeOf($info)
+      if ($type::GetLastInputInfo([ref]$info)) {
+          $idleMs = [Environment]::TickCount - $info.dwTime
+          [Math]::Round($idleMs / 1000)
+      } else {
+          0
+      }
+    `
+    const { stdout } = await execPromise(
+      `powershell -NoProfile -NonInteractive -Command "${psScript.replace(/\n/g, ' ')}"`
+    )
+    return parseInt(stdout.trim(), 10) || 0
+  } catch {
+    return 0
+  }
+}
+
+export function startOsActivityTracking(intervalMs = 10000) {
+  if (trackerInterval) clearInterval(trackerInterval)
+
+  // Langsung panggil sekali saat start jika awareness aktif
+  const cfg = getActiveConfig() || {}
+  if (cfg.awarenessEnabled !== false) {
+    if (process.platform === 'win32' && !isDaemonAlive()) {
+      startDaemon().catch(() => {})
+    }
+    getActiveWindowFallback().then((win) => {
+      if (win) recordActivityEntry(win)
+    })
+  }
+
+  trackerInterval = setInterval(async () => {
+    try {
+      const currentCfg = getActiveConfig() || {}
+      if (currentCfg.awarenessEnabled === false) return
+
+      const windowInfo = await getActiveWindowFallback()
+      if (windowInfo) {
+        recordActivityEntry(windowInfo)
+      }
+    } catch {
+      // ignore
+    }
+  }, intervalMs)
+}
+
+export function stopOsActivityTracking() {
+  if (trackerInterval) {
+    clearInterval(trackerInterval)
+    trackerInterval = null
+  }
+}
+
+export function getActivityBuffer() {
+  return [...activityBuffer]
+}
+
+export function clearActivityBuffer() {
+  activityBuffer.length = 0
+}
+
+export async function getSystemTelemetry() {
+  const idleSeconds = await getSystemIdleSeconds()
+  const battery = await getBatteryTelemetry()
+  const totalMem = os.totalmem()
+  const freeMem = os.freemem()
+  const ramPercent = Math.round(((totalMem - freeMem) / totalMem) * 100)
+  const cpuPercent = sampleCpuPercent()
+  const uptimeSeconds = os.uptime()
+  const uptimeHours = Math.round((uptimeSeconds / 3600) * 10) / 10
+  const isFreshBoot = uptimeSeconds < 1800
+  const activeDurationMinutes = Math.max(0, Math.floor((Date.now() - currentAppStartTime) / 60000))
+
+  return {
+    idleSeconds,
+    isUserAFK: idleSeconds >= 900,
+    activeApp: currentActiveApp || 'System',
+    activeTitle: currentActiveTitle || '',
+    activeAppDurationMinutes: activeDurationMinutes,
+    battery,
+    hardware: {
+      ramPercent,
+      cpuPercent,
+      uptimeHours,
+      isFreshBoot
+    }
+  }
+}