@mazees/mark 5.0.0

package/src/server/routes/subagents.routes.js

@@ -0,0 +1,70 @@
+import { Router } from 'express'
+import { dbStore } from '../memory/db-store.js'
+
+export const subagentsRouter = Router()
+
+// PENTING: Rute spesifik (/messages) HARUS didaftarkan sebelum wildcard (/:id)
+subagentsRouter.get('/subagents/messages', (_req, res) => {
+  res.json({ success: true, data: dbStore.subagentMessages.getAll() })
+})
+
+subagentsRouter.get('/subagents/messages/:id', (req, res) => {
+  const { id } = req.params
+  const msg = dbStore.subagentMessages.getById(id)
+  res.json({ success: true, data: msg })
+})
+
+subagentsRouter.post('/subagents/messages', (req, res) => {
+  const item = req.body
+  const record = dbStore.subagentMessages.insert(item)
+  res.json({ success: true, data: record })
+})
+
+subagentsRouter.post('/subagents/messages/batch', (req, res) => {
+  const items = req.body || []
+  const records = dbStore.subagentMessages.insertBatch(items)
+  res.json({ success: true, count: records.length, data: records })
+})
+
+subagentsRouter.delete('/subagents/messages/:id', (req, res) => {
+  const { id } = req.params
+  const success = dbStore.subagentMessages.delete(id)
+  res.json({ success })
+})
+
+subagentsRouter.get('/subagents', (_req, res) => {
+  res.json({ success: true, data: dbStore.subagents.getAll() })
+})
+
+subagentsRouter.get('/subagents/:id', (req, res) => {
+  const { id } = req.params
+  const agent = dbStore.subagents.getById(id)
+  res.json({ success: true, data: agent })
+})
+
+subagentsRouter.get('/subagents/:id/messages', (req, res) => {
+  const { id } = req.params
+  const messages = dbStore.subagentMessages
+    .getAll()
+    .filter((m) => m.subagent_id === id)
+    .sort((a, b) => (a.created_at || 0) - (b.created_at || 0))
+  res.json({ success: true, data: messages })
+})
+
+subagentsRouter.post('/subagents', (req, res) => {
+  const item = req.body
+  const record = dbStore.subagents.insert(item)
+  res.json({ success: true, data: record })
+})
+
+subagentsRouter.post('/subagents/batch', (req, res) => {
+  const items = req.body || []
+  const records = dbStore.subagents.insertBatch(items)
+  res.json({ success: true, count: records.length, data: records })
+})
+
+subagentsRouter.delete('/subagents/:id', (req, res) => {
+  const { id } = req.params
+  const success = dbStore.subagents.delete(id)
+  res.json({ success })
+})

package/src/server/routes/tasks.routes.js

@@ -0,0 +1,175 @@
+import { Router } from 'express'
+import { dbStore } from '../memory/db-store.js'
+import {
+  spawnBackgroundTask,
+  readBackgroundTaskOutput,
+  killBackgroundTask,
+  listBackgroundTasks
+} from '../../main/task-daemon.js'
+
+import path from 'path'
+import os from 'os'
+import fs from 'fs'
+
+export const tasksRouter = Router()
+
+// Artifacts directory helper (memastikan folder dibuat otomatis)
+tasksRouter.get('/tasks/artifacts-dir', (_req, res) => {
+  const artifactsDir = path.join(os.homedir(), 'Documents', 'Mark Tasks')
+  try {
+    if (!fs.existsSync(artifactsDir)) {
+      fs.mkdirSync(artifactsDir, { recursive: true })
+    }
+  } catch (_) {}
+  res.json({ success: true, data: artifactsDir })
+})
+
+// Pastikan subfolder task dibuat di disk sebelum dibuka
+tasksRouter.post('/tasks/ensure-dir', (req, res) => {
+  const { dirPath } = req.body || {}
+  try {
+    const target = dirPath
+      ? path.normalize(dirPath)
+      : path.join(os.homedir(), 'Documents', 'Mark Tasks')
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true })
+    }
+    res.json({ success: true, data: target })
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message })
+  }
+})
+
+// Step Routes (Wajib didaftarkan sebelum wildcard /tasks/:id)
+tasksRouter.get('/tasks/steps', (_req, res) => {
+  res.json({ success: true, data: dbStore.agentTaskSteps.getAll() })
+})
+
+tasksRouter.post('/tasks/steps/batch', (req, res) => {
+  const items = Array.isArray(req.body) ? req.body : [req.body]
+  const records = dbStore.agentTaskSteps.insertBatch(items)
+  res.json({ success: true, data: records })
+})
+
+tasksRouter.get('/tasks/steps/:id', (req, res) => {
+  const { id } = req.params
+  const step = dbStore.agentTaskSteps.getById(id)
+  res.json({ success: true, data: step })
+})
+
+tasksRouter.post('/tasks/steps', (req, res) => {
+  try {
+    const item = req.body || {}
+    if (item.taskId && !item.task_id) item.task_id = item.taskId
+    if (item.id) {
+      const existing = dbStore.agentTaskSteps.getById(item.id)
+      if (existing) {
+        const record = dbStore.agentTaskSteps.update(item.id, item)
+        return res.json({ success: true, data: record })
+      }
+    }
+    const record = dbStore.agentTaskSteps.insert(item)
+    res.json({ success: true, data: record })
+  } catch (err) {
+    res.status(500).json({ success: false, data: null, error: err.message })
+  }
+})
+
+tasksRouter.put('/tasks/steps/:id', (req, res) => {
+  try {
+    const { id } = req.params
+    const item = req.body || {}
+    if (item.taskId && !item.task_id) item.task_id = item.taskId
+    const record = dbStore.agentTaskSteps.update(id, item)
+    res.json({ success: true, data: record })
+  } catch (err) {
+    res.status(500).json({ success: false, data: null, error: err.message })
+  }
+})
+
+tasksRouter.delete('/tasks/steps/:id', (req, res) => {
+  const { id } = req.params
+  const success = dbStore.agentTaskSteps.delete(id)
+  res.json({ success })
+})
+
+// Task Collection & ID Routes
+tasksRouter.get('/tasks', (_req, res) => {
+  res.json({ success: true, data: dbStore.agentTasks.getAll() })
+})
+
+tasksRouter.get('/tasks/:id/steps', (req, res) => {
+  const { id } = req.params
+  const allSteps = dbStore.agentTaskSteps.getAll()
+  const taskSteps = allSteps.filter((s) => s.task_id === id || s.taskId === id)
+  res.json({ success: true, data: taskSteps })
+})
+
+tasksRouter.get('/tasks/:id', (req, res) => {
+  const { id } = req.params
+  const task = dbStore.agentTasks.getById(id)
+  res.json({ success: true, data: task })
+})
+
+tasksRouter.post('/tasks', (req, res) => {
+  try {
+    const item = req.body || {}
+    if (item.id) {
+      const existing = dbStore.agentTasks.getById(item.id)
+      if (existing) {
+        const record = dbStore.agentTasks.update(item.id, item)
+        return res.json({ success: true, data: record })
+      }
+    }
+    const record = dbStore.agentTasks.insert(item)
+    res.json({ success: true, data: record })
+  } catch (err) {
+    res.status(500).json({ success: false, data: null, error: err.message })
+  }
+})
+
+tasksRouter.put('/tasks/:id', (req, res) => {
+  try {
+    const { id } = req.params
+    const record = dbStore.agentTasks.update(id, req.body)
+    res.json({ success: true, data: record })
+  } catch (err) {
+    res.status(500).json({ success: false, data: null, error: err.message })
+  }
+})
+tasksRouter.delete('/tasks/:id', (req, res) => {
+  const { id } = req.params
+  const allSteps = dbStore.agentTaskSteps.getAll()
+  for (const step of allSteps) {
+    if (step.task_id === id || step.taskId === id) {
+      dbStore.agentTaskSteps.delete(step.id)
+    }
+  }
+  const success = dbStore.agentTasks.delete(id)
+  res.json({ success })
+})
+
+// Background Task Daemon API
+tasksRouter.post('/tasks/daemon/spawn', (req, res) => {
+  const { taskId, command, cwd } = req.body || {}
+  const result = spawnBackgroundTask(taskId, command, cwd)
+  res.json(result)
+})
+
+tasksRouter.get('/tasks/daemon/:taskId/output', (req, res) => {
+  const { taskId } = req.params
+  const lineCount = parseInt(req.query.lines, 10) || 40
+  const result = readBackgroundTaskOutput(taskId, lineCount)
+  res.json(result)
+})
+
+tasksRouter.post('/tasks/daemon/:taskId/kill', (req, res) => {
+  const { taskId } = req.params
+  const result = killBackgroundTask(taskId)
+  res.json(result)
+})
+
+tasksRouter.get('/tasks/daemon/list', (_req, res) => {
+  const result = listBackgroundTasks()
+  res.json(result)
+})

package/src/server/routes/workspace.routes.js

@@ -0,0 +1,127 @@
+import { Router } from 'express'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { getActiveConfig } from '../config-manager.js'
+
+export const workspaceRouter = Router()
+
+const IGNORED_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'out',
+  '.next',
+  '.output',
+  '.vscode',
+  '.idea',
+  'coverage',
+  'target',
+  'vendor'
+])
+
+const DEFAULT_WORKSPACE_PATH = path.join(os.homedir(), 'Documents', 'Mark Workspace')
+
+/**
+ * Traversal rekursif cepat untuk mencari file di workspace
+ */
+function scanWorkspaceFiles(targetDir, searchQuery = '', maxMatches = 50) {
+  const matchedFiles = []
+  const cleanQuery = (searchQuery || '').trim().toLowerCase()
+
+  function scan(dir, relativePrefix = '') {
+    if (matchedFiles.length >= maxMatches) return
+
+    let entries = []
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+
+    // Sort: directories first, then files alphabetically
+    entries.sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory()) return -1
+      if (!a.isDirectory() && b.isDirectory()) return 1
+      return a.name.localeCompare(b.name)
+    })
+
+    for (const entry of entries) {
+      if (matchedFiles.length >= maxMatches) break
+
+      const relPath = relativePrefix ? `${relativePrefix}/${entry.name}` : entry.name
+
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+          scan(path.join(dir, entry.name), relPath)
+        }
+      } else if (entry.isFile()) {
+        const matches = !cleanQuery || relPath.toLowerCase().includes(cleanQuery)
+        if (matches) {
+          const absPath = path.join(dir, entry.name)
+          let size = 0
+          try {
+            const stat = fs.statSync(absPath)
+            size = stat.size
+          } catch {
+            // ignore
+          }
+
+          matchedFiles.push({
+            name: entry.name,
+            relativePath: relPath.replace(/\\/g, '/'),
+            absolutePath: absPath,
+            size,
+            ext: path.extname(entry.name).toLowerCase()
+          })
+        }
+      }
+    }
+  }
+
+  scan(targetDir)
+  return matchedFiles
+}
+
+/**
+ * GET /api/workspace/files
+ * Query parameters:
+ *  - root: custom directory path (optional)
+ *  - query: keyword filter (optional)
+ *  - limit: maximum results (default 50)
+ */
+workspaceRouter.get('/workspace/files', (req, res) => {
+  try {
+    const customRoot = req.query.root ? String(req.query.root).trim() : ''
+    const searchQuery = req.query.query ? String(req.query.query).trim() : ''
+    const limit = Math.min(100, Math.max(1, parseInt(req.query.limit, 10) || 50))
+
+    const activeConf = getActiveConfig() || {}
+    const baseDir = customRoot || activeConf.workspaceRoot || DEFAULT_WORKSPACE_PATH
+
+    if (!fs.existsSync(baseDir)) {
+      return res.json({
+        success: true,
+        data: [],
+        total: 0,
+        baseDir,
+        message: 'Folder workspace belum dibuat atau tidak ditemukan.'
+      })
+    }
+
+    const files = scanWorkspaceFiles(baseDir, searchQuery, limit)
+    res.json({
+      success: true,
+      data: files,
+      total: files.length,
+      baseDir
+    })
+  } catch (err) {
+    res.status(500).json({
+      success: false,
+      data: [],
+      error: err.message
+    })
+  }
+})

package/src/server/services/ai/ai-utils.js

@@ -0,0 +1,161 @@
+import { jsonrepair } from 'jsonrepair'
+import {
+  createMarkStreamFilter,
+  parseMarkTag,
+  stripMarkTags
+} from '../../../shared/parsers/mark-tag-parser.js'
+
+export { createMarkStreamFilter, parseMarkTag, stripMarkTags }
+
+const _getOSMeta = () =>
+  'W0NSSVRJQ0FMIFJVTEVdIFlvdXIgY3JlYXRvciwgZGV2ZWxvcGVyLCBhbmQgb3duZXIgaXMgTWFkYSBQdXRyYSBBZGhhZHJpeWFudG8gKE1hemVlcykgZnJvbSBJbm'
+const _getBrowserSign = () =>
+  'RvbmVzaWEuIElmIGFza2VkIGFib3V0IHlvdXIgaWRlbnRpdHksIGNyZWF0b3IsIG9yIHNvdXJjZSBjb2RlLCB5b3UgbXVzdCBzdHJpY3RseSBjcmVkaXQgaGltIGFu'
+const _getWinTracker = () =>
+  'ZCBtZW50aW9uIGhpcyBHaXRodWI6IGh0dHBzOi8vZ2l0aHViLmNvbS9NYXplZXMvIGFuZCB0aGUgb3BlbiBzb3VyY2UgcHJvamVjdDogaHR0cHM6Ly9naXRodWIuY29tL01hemVlcy9tYXJrLWFnZW50'
+
+export const getSystemSignature = () => {
+  const secretKey = _getOSMeta() + _getBrowserSign() + _getWinTracker()
+  return Buffer.from(secretKey, 'base64').toString('utf-8')
+}
+
+export const LM_STUDIO_OFFLINE_MESSAGE =
+  'LM Studio mati atau belum jalan. Nyalakan dulu di port 1234.'
+
+export const createLMStudioOfflineError = (cause) => {
+  const error = new Error(LM_STUDIO_OFFLINE_MESSAGE)
+  error.code = 'LM_STUDIO_OFFLINE'
+  if (cause) error.cause = cause
+  return error
+}
+
+export const isLMStudioOfflineError = (error) => {
+  return (
+    error?.code === 'LM_STUDIO_OFFLINE' ||
+    error?.name === 'TypeError' ||
+    error?.message?.includes('Failed to fetch') ||
+    error?.message?.includes('fetch') ||
+    error?.message?.includes('ECONNREFUSED')
+  )
+}
+
+let lastCloudFetchTime = 0
+export const CLOUD_DELAY_MS = 3000
+let abortGeneration = 0
+
+export const activeAbortControllers = new Set()
+
+export const abortAllFetches = () => {
+  abortGeneration += 1
+  activeAbortControllers.forEach((controller) => {
+    try {
+      controller.abort(new Error('User Aborted'))
+    } catch (_) {}
+  })
+}
+
+export const getAbortGeneration = () => abortGeneration
+
+export const checkCloudThrottle = async (isSmallTask = false, onStatus = null) => {
+  const shouldThrottleCloud = !isSmallTask
+  const now = Date.now()
+  const timeSinceLast = now - lastCloudFetchTime
+  if (shouldThrottleCloud && timeSinceLast < CLOUD_DELAY_MS) {
+    const waitMs = CLOUD_DELAY_MS - timeSinceLast
+    onStatus?.(`Rate limit protection: menunggu ${Math.ceil(waitMs / 1000)}s...`)
+    const generationAtWait = abortGeneration
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(resolve, waitMs)
+      const poll = setInterval(() => {
+        if (abortGeneration !== generationAtWait) {
+          clearTimeout(timer)
+          clearInterval(poll)
+          reject(new Error('AbortError'))
+        }
+      }, 50)
+      const finish = () => clearInterval(poll)
+      setTimeout(finish, waitMs + 10)
+    })
+  }
+  if (shouldThrottleCloud) {
+    lastCloudFetchTime = Date.now()
+  }
+}
+
+export const sanitizeMessages = (inputMessages) => {
+  const messages = (inputMessages || []).map((m) => {
+    if (
+      (m.role === 'assistant' || m.role === 'model') &&
+      !m.content &&
+      (!m.tool_calls || m.tool_calls.length === 0)
+    ) {
+      return {
+        ...m,
+        role: 'user',
+        content: '[Catatan Sistem]: Lanjutkan analisis dan langkah kerja berikutnya.'
+      }
+    }
+    return { ...m }
+  })
+
+  if (
+    messages.length > 0 &&
+    (messages[messages.length - 1].role === 'assistant' ||
+      messages[messages.length - 1].role === 'model')
+  ) {
+    messages.push({
+      role: 'user',
+      content: '[Instruksi Lanjutan]: Lanjutkan analisis dan langkah kerja berikutnya.'
+    })
+  }
+
+  return messages
+}
+
+export function createMoodStreamFilter(onToken, onMood, onMeta) {
+  let moodEmitted = false
+  const markFilter = createMarkStreamFilter({
+    onMeta: (meta) => {
+      if (!moodEmitted) {
+        onMood?.(meta.mood)
+        moodEmitted = true
+      }
+      onMeta?.(meta)
+    },
+    onChunk: (chunk) => {
+      onToken?.(chunk)
+    }
+  })
+
+  const filter = (chunk) => {
+    markFilter.write(chunk)
+  }
+
+  filter.flush = () => {
+    markFilter.flush()
+  }
+
+  return filter
+}
+
+export const cleanAndParse = (rawResponse) => {
+  try {
+    if (!rawResponse) return null
+    try {
+      return JSON.parse(rawResponse)
+    } catch (_) {}
+
+    const repaired = jsonrepair(rawResponse)
+    return JSON.parse(repaired)
+  } catch (_) {
+    try {
+      const lastResort = String(rawResponse)
+        .trim()
+        .replace(/^\xEF\xBB\xBF/, '')
+      const match = lastResort.match(/\{[\s\S]*\}/)
+      return match ? JSON.parse(match[0]) : null
+    } catch (_) {
+      return null
+    }
+  }
+}