@mazees/mark 5.0.0

package/src/main/git-service.js

@@ -0,0 +1,90 @@
+import { exec } from 'child_process'
+import util from 'util'
+import fs from 'fs'
+
+const execPromise = util.promisify(exec)
+
+function validateRepoCwd(cwd) {
+  const target = cwd || process.cwd()
+  if (!fs.existsSync(target)) {
+    return { valid: false, error: `Direktori '${target}' tidak ditemukan.` }
+  }
+  return { valid: true, target }
+}
+
+function formatGitError(err, target) {
+  const msg = err?.message || String(err)
+  if (msg.includes('not a git repository')) {
+    return `Folder '${target}' bukan repositori Git.`
+  }
+  return msg
+}
+
+/**
+ * Mendapatkan status berkas repositori git (git status --short)
+ */
+export async function getGitStatus(cwd) {
+  const check = validateRepoCwd(cwd)
+  if (!check.valid) return { success: false, error: check.error }
+  try {
+    const { stdout } = await execPromise('git status --short', { cwd: check.target })
+    return {
+      success: true,
+      status: stdout.trim() || 'Working tree clean (tidak ada perubahan berkas).'
+    }
+  } catch (err) {
+    return { success: false, error: formatGitError(err, check.target) }
+  }
+}
+/**
+ * Mendapatkan perubahan baris kode (git diff)
+ */
+export async function getGitDiff(cwd, filePath = '') {
+  const check = validateRepoCwd(cwd)
+  if (!check.valid) return { success: false, error: check.error }
+  try {
+    const cleanPath = filePath ? ` -- "${filePath.trim()}"` : ''
+    const { stdout } = await execPromise(`git diff${cleanPath}`, { cwd: check.target })
+    return {
+      success: true,
+      diff: stdout.trim() || 'Tidak ada perbedaan baris kode yang belum di-commit.'
+    }
+  } catch (err) {
+    return { success: false, error: formatGitError(err, check.target) }
+  }
+}
+
+/**
+ * Membuat checkpoint commit git otomatis
+ */
+export async function gitCommit(cwd, message = 'Mark Agent Checkpoint') {
+  const check = validateRepoCwd(cwd)
+  if (!check.valid) return { success: false, error: check.error }
+  try {
+    await execPromise('git add -A', { cwd: check.target })
+    const safeMsg = message.replace(/"/g, '\\"')
+    const { stdout } = await execPromise(`git commit -m "${safeMsg}"`, { cwd: check.target })
+    return { success: true, message: stdout.trim() }
+  } catch (err) {
+    return { success: false, error: formatGitError(err, check.target) }
+  }
+}
+
+/**
+ * Me-rollback perubahan file ke HEAD
+ */
+export async function gitRevert(cwd, filePath = '') {
+  const check = validateRepoCwd(cwd)
+  if (!check.valid) return { success: false, error: check.error }
+  try {
+    if (filePath && filePath.trim()) {
+      await execPromise(`git checkout -- "${filePath.trim()}"`, { cwd: check.target })
+      return { success: true, message: `Berhasil me-rollback perubahan pada berkas ${filePath}.` }
+    } else {
+      await execPromise('git reset --hard HEAD', { cwd: check.target })
+      return { success: true, message: 'Berhasil me-rollback seluruh repositori ke HEAD.' }
+    }
+  } catch (err) {
+    return { success: false, error: formatGitError(err, check.target) }
+  }
+}

package/src/main/google/google-calendar.js

@@ -0,0 +1,69 @@
+import { google } from 'googleapis'
+import { getAuthClient } from './google-service.js'
+
+/**
+ * Helper to initialize the Calendar API.
+ */
+export async function getCalendarApi(clientId, clientSecret) {
+  const auth = await getAuthClient(clientId, clientSecret)
+  if (!auth) throw new Error('Not connected to Google Workspace.')
+  return google.calendar({ version: 'v3', auth })
+}
+
+/**
+ * gcalendar-list: Get upcoming events.
+ */
+export async function listEvents(clientId, clientSecret, maxResults = 10, timeMin = new Date().toISOString()) {
+  const calendar = await getCalendarApi(clientId, clientSecret)
+  const res = await calendar.events.list({
+    calendarId: 'primary',
+    timeMin,
+    maxResults,
+    singleEvents: true,
+    orderBy: 'startTime',
+  })
+  return res.data.items.map(event => ({
+    id: event.id,
+    summary: event.summary,
+    description: event.description,
+    start: event.start.dateTime || event.start.date,
+    end: event.end.dateTime || event.end.date,
+    link: event.htmlLink
+  }))
+}
+
+/**
+ * gcalendar-create: Create a new event.
+ */
+export async function createEvent(clientId, clientSecret, summary, description, startTime, endTime) {
+  const calendar = await getCalendarApi(clientId, clientSecret)
+  const event = {
+    summary,
+    description,
+    start: {
+      dateTime: new Date(startTime).toISOString(),
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    },
+    end: {
+      dateTime: new Date(endTime).toISOString(),
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    },
+  }
+  const res = await calendar.events.insert({
+    calendarId: 'primary',
+    resource: event,
+  })
+  return res.data
+}
+
+/**
+ * gcalendar-delete: Delete an event.
+ */
+export async function deleteEvent(clientId, clientSecret, eventId) {
+  const calendar = await getCalendarApi(clientId, clientSecret)
+  await calendar.events.delete({
+    calendarId: 'primary',
+    eventId,
+  })
+  return { success: true, message: 'Event deleted successfully.' }
+}

package/src/main/google/google-drive.js

@@ -0,0 +1,263 @@
+import fs from 'fs'
+import path from 'path'
+import { google } from 'googleapis'
+import { getAuthClient } from './google-service.js'
+
+/**
+ * Helper to initialize the Drive API.
+ */
+export async function getDriveApi(clientId, clientSecret) {
+  const auth = await getAuthClient(clientId, clientSecret)
+  if (!auth) throw new Error('Not connected to Google Workspace.')
+  return google.drive({ version: 'v3', auth })
+}
+
+/**
+ * gdrive-search: Searches files by name or mimeType.
+ */
+export async function searchFiles(clientId, clientSecret, query, maxResults = 10) {
+  const drive = await getDriveApi(clientId, clientSecret)
+  // Build a simple query, or use the raw query if advanced
+  // Let's assume the query is a simple string for name matching
+  // Or the agent can pass standard Google Drive 'q' syntax.
+  const q = query.includes(':') ? query : `name contains '${query}' and trashed = false`
+
+  const res = await drive.files.list({
+    q,
+    pageSize: maxResults,
+    fields: 'nextPageToken, files(id, name, mimeType, modifiedTime)'
+  })
+  return res.data.files
+}
+
+/**
+ * gdrive-list: List recent files or files in a folder.
+ */
+export async function listFiles(clientId, clientSecret, folderId = null, maxResults = 10) {
+  const drive = await getDriveApi(clientId, clientSecret)
+  const q = folderId ? `'${folderId}' in parents and trashed = false` : `trashed = false`
+  const res = await drive.files.list({
+    q,
+    pageSize: maxResults,
+    orderBy: 'modifiedTime desc',
+    fields: 'nextPageToken, files(id, name, mimeType, modifiedTime)'
+  })
+  return res.data.files
+}
+
+/**
+ * gdrive-read: Read text content from a Google Doc, Sheet, or raw text file.
+ */
+export async function readFile(clientId, clientSecret, fileId) {
+  const drive = await getDriveApi(clientId, clientSecret)
+
+  // First get file metadata to know its mimeType
+  const fileMeta = await drive.files.get({ fileId, fields: 'name, mimeType' })
+  const mimeType = fileMeta.data.mimeType
+
+  try {
+    if (mimeType === 'application/vnd.google-apps.document') {
+      // Google Docs -> export as text
+      const res = await drive.files.export({
+        fileId,
+        mimeType: 'text/plain'
+      })
+      return res.data
+    } else if (mimeType === 'application/vnd.google-apps.spreadsheet') {
+      // Google Sheets -> export as CSV
+      const res = await drive.files.export({
+        fileId,
+        mimeType: 'text/csv'
+      })
+      return res.data
+    } else {
+      // Standard files (txt, etc) -> download directly
+      const res = await drive.files.get(
+        {
+          fileId,
+          alt: 'media'
+        },
+        { responseType: 'text' }
+      )
+      return res.data
+    }
+  } catch (error) {
+    throw new Error(`Failed to read file: ${error.message}`)
+  }
+}
+
+/**
+ * gdrive-upload: Upload local file to Google Drive.
+ */
+export async function uploadFile(clientId, clientSecret, filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Berkas tidak ditemukan: ${filePath}`)
+  }
+  const drive = await getDriveApi(clientId, clientSecret)
+  const name = path.basename(filePath)
+  const ext = path.extname(filePath).toLowerCase()
+  const mimeMap = {
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.json': 'application/json',
+    '.csv': 'text/csv',
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.zip': 'application/zip',
+    '.tar': 'application/x-tar',
+    '.gz': 'application/gzip',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4',
+    '.mkv': 'video/x-matroska'
+  }
+  const mimeType = mimeMap[ext] || 'application/octet-stream'
+
+  const res = await drive.files.create({
+    requestBody: { name, mimeType },
+    media: { mimeType, body: fs.createReadStream(filePath) },
+    fields: 'id, name, mimeType, webViewLink, size'
+  })
+  return res.data
+}
+
+/**
+ * gdrive-create: Create an empty Google Doc or Sheet.
+ */
+export async function createFile(clientId, clientSecret, name, type = 'doc') {
+  const drive = await getDriveApi(clientId, clientSecret)
+  const mimeMap = {
+    doc: 'application/vnd.google-apps.document',
+    sheet: 'application/vnd.google-apps.spreadsheet',
+    folder: 'application/vnd.google-apps.folder'
+  }
+  const mimeType = mimeMap[type] || mimeMap['doc']
+
+  const res = await drive.files.create({
+    requestBody: { name, mimeType },
+    fields: 'id, name, webViewLink'
+  })
+  return res.data
+}
+
+/**
+ * gdrive-move: Move a file to a specific folder.
+ */
+export async function moveFile(clientId, clientSecret, fileId, folderId) {
+  const drive = await getDriveApi(clientId, clientSecret)
+
+  // Get current parents
+  const file = await drive.files.get({ fileId, fields: 'parents' })
+  const previousParents = file.data.parents ? file.data.parents.join(',') : ''
+
+  // Move
+  const res = await drive.files.update({
+    fileId,
+    addParents: folderId,
+    removeParents: previousParents,
+    fields: 'id, parents'
+  })
+  return res.data
+}
+
+/**
+ * gdrive-copy: Copy a file.
+ */
+export async function copyFile(clientId, clientSecret, fileId, newName) {
+  const drive = await getDriveApi(clientId, clientSecret)
+  const res = await drive.files.copy({
+    fileId,
+    requestBody: { name: newName },
+    fields: 'id, name, webViewLink'
+  })
+  return res.data
+}
+
+/**
+ * gdrive-info: Get Google Drive storage info.
+ */
+export async function getDriveInfo(clientId, clientSecret) {
+  const drive = await getDriveApi(clientId, clientSecret)
+  const res = await drive.about.get({
+    fields: 'storageQuota, user'
+  })
+
+  const quota = res.data.storageQuota
+  const user = res.data.user
+
+  if (!quota) return { error: 'Storage quota not available.' }
+
+  const limit = parseInt(quota.limit, 10) || 0
+  const usage = parseInt(quota.usage, 10) || 0
+  const usageInDrive = parseInt(quota.usageInDrive, 10) || 0
+  const usageInDriveTrash = parseInt(quota.usageInDriveTrash, 10) || 0
+
+  const formatBytes = (bytes) => {
+    if (bytes === 0) return '0 B'
+    const k = 1024
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
+    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+  }
+
+  return {
+    user: user.emailAddress,
+    totalStorage: formatBytes(limit),
+    usedStorage: formatBytes(usage),
+    freeStorage: formatBytes(limit - usage),
+    usagePercentage: limit > 0 ? ((usage / limit) * 100).toFixed(1) + '%' : 'N/A',
+    driveUsage: formatBytes(usageInDrive),
+    trashUsage: formatBytes(usageInDriveTrash)
+  }
+}
+
+/**
+ * gdrive-share: Share file or change file permission (e.g. public anyone reader, or specific email).
+ */
+export async function shareFile(
+  clientId,
+  clientSecret,
+  fileId,
+  role = 'reader',
+  type = 'anyone',
+  emailAddress = null
+) {
+  const drive = await getDriveApi(clientId, clientSecret)
+  const permission = {
+    role,
+    type
+  }
+  if (emailAddress && (type === 'user' || type === 'group')) {
+    permission.emailAddress = emailAddress
+  }
+
+  const permRes = await drive.permissions.create({
+    fileId,
+    requestBody: permission,
+    fields: 'id, type, role, emailAddress'
+  })
+
+  const fileRes = await drive.files.get({
+    fileId,
+    fields: 'id, name, webViewLink'
+  })
+
+  return {
+    permission: permRes.data,
+    name: fileRes.data.name,
+    webViewLink: fileRes.data.webViewLink
+  }
+}

package/src/main/google/google-gmail.js

@@ -0,0 +1,131 @@
+import { google } from 'googleapis'
+import { getAuthClient } from './google-service.js'
+
+/**
+ * Helper to initialize the Gmail API.
+ */
+export async function getGmailApi(clientId, clientSecret) {
+  const auth = await getAuthClient(clientId, clientSecret)
+  if (!auth) throw new Error('Not connected to Google Workspace.')
+  return google.gmail({ version: 'v1', auth })
+}
+
+/**
+ * gmail-search: Search emails.
+ */
+export async function searchEmails(clientId, clientSecret, query = 'is:unread', maxResults = 10) {
+  const gmail = await getGmailApi(clientId, clientSecret)
+  const res = await gmail.users.messages.list({
+    userId: 'me',
+    q: query,
+    maxResults
+  })
+  
+  if (!res.data.messages) return []
+
+  // Fetch details for each message
+  const messages = await Promise.all(res.data.messages.map(async (msg) => {
+    const detail = await gmail.users.messages.get({
+      userId: 'me',
+      id: msg.id,
+      format: 'metadata',
+      metadataHeaders: ['From', 'Subject', 'Date']
+    })
+    
+    const headers = detail.data.payload.headers
+    return {
+      id: detail.data.id,
+      snippet: detail.data.snippet,
+      from: headers.find(h => h.name === 'From')?.value || 'Unknown',
+      subject: headers.find(h => h.name === 'Subject')?.value || 'No Subject',
+      date: headers.find(h => h.name === 'Date')?.value || ''
+    }
+  }))
+  
+  return messages
+}
+
+/**
+ * gmail-read: Get full body of an email.
+ */
+export async function readEmail(clientId, clientSecret, messageId) {
+  const gmail = await getGmailApi(clientId, clientSecret)
+  const res = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'full'
+  })
+  
+  // Gmail bodies are base64url encoded. We need to decode it.
+  const getBody = (payload) => {
+    if (payload.body && payload.body.data) {
+      return Buffer.from(payload.body.data, 'base64').toString('utf-8')
+    }
+    if (payload.parts) {
+      for (const part of payload.parts) {
+        if (part.mimeType === 'text/plain') {
+          return Buffer.from(part.body.data, 'base64').toString('utf-8')
+        }
+      }
+    }
+    return 'No plain text body found.'
+  }
+
+  const body = getBody(res.data.payload)
+  const headers = res.data.payload.headers
+  
+  return {
+    id: res.data.id,
+    from: headers.find(h => h.name === 'From')?.value,
+    subject: headers.find(h => h.name === 'Subject')?.value,
+    date: headers.find(h => h.name === 'Date')?.value,
+    body
+  }
+}
+
+/**
+ * gmail-send: Send an email.
+ */
+export async function sendEmail(clientId, clientSecret, to, subject, bodyText) {
+  const gmail = await getGmailApi(clientId, clientSecret)
+  
+  // Construct raw email according to RFC 2822
+  const rawEmail = [
+    `To: ${to}`,
+    `Subject: ${subject}`,
+    'Content-Type: text/plain; charset="UTF-8"',
+    '',
+    bodyText
+  ].join('\n')
+  
+  // Base64url encode
+  const encodedEmail = Buffer.from(rawEmail)
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '')
+
+  const res = await gmail.users.messages.send({
+    userId: 'me',
+    requestBody: {
+      raw: encodedEmail
+    }
+  })
+  return res.data
+}
+
+/**
+ * gmail-mark-read: Mark an email as read.
+ */
+export async function markAsRead(clientId, clientSecret, messageId) {
+  const gmail = await getGmailApi(clientId, clientSecret)
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      removeLabelIds: ['UNREAD']
+    }
+  })
+  return { success: true, messageId }
+}
+