clawkit-ai 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawkit-ai",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Transform your OpenClaw agent into a production-ready AI assistant with memory, skills, and a dashboard",
   "type": "module",
   "bin": {

package/src/sync.mjs

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { execSync } from 'child_process';
 import { c, log, detectWorkspace } from './utils.mjs';
 
 const API_BASE = 'https://clawkit-api.vercel.app';
@@ -11,16 +12,22 @@ function getApiKey() {
 // --- Connected Accounts: parse from TOOLS.md ---
 
 const SERVICE_PATTERNS = [
-  { key: 'google_sheets', names: ['Google Sheets'], patterns: [/Google Sheets.*Connection.*?[:`]\s*`?([^\s`]+)/i, /Sheets.*ID.*?[:`]\s*`?([^\s`]+)/i] },
-  { key: 'google_docs', names: ['Google Docs'], patterns: [/Google Docs.*Connection.*?[:`]\s*`?([^\s`]+)/i, /Docs.*ID.*?[:`]\s*`?([^\s`]+)/i] },
-  { key: 'twitter', names: ['Twitter', 'X', '@'], patterns: [/(?:Twitter|X).*(?:Consumer|API)\s*Key.*?[:`]\s*`?([^\s`]+)/i, /(?:Twitter|X).*Bearer.*?[:`]\s*`?([^\s`]+)/i] },
-  { key: 'stripe', names: ['Stripe'], patterns: [/Stripe.*Secret.*?[:`]\s*`?(sk_[^\s`]+)/i, /Stripe.*Publishable.*?[:`]\s*`?(pk_[^\s`]+)/i] },
-  { key: 'openai', names: ['OpenAI', 'Sora'], patterns: [/(?:OpenAI|Sora).*(?:Key|API).*?[:`]\s*`?(sk-[^\s`]+)/i] },
-  { key: 'anthropic', names: ['Anthropic', 'Claude'], patterns: [/Anthropic.*(?:Key|API).*?[:`]\s*`?(sk-ant-[^\s`]+)/i] },
-  { key: 'brave_search', names: ['Brave'], patterns: [/Brave.*(?:Key|API).*?[:`]\s*`?([^\s`]+)/i] },
+  { key: 'google_sheets', names: ['Google Sheets'], patterns: [/Google Sheets.*?(?:Connection|ID).*?[:`]\s*`?([0-9a-f-]{20,})/i] },
+  { key: 'google_docs', names: ['Google Docs'], patterns: [/Google Docs.*?(?:Connection|ID).*?[:`]\s*`?([0-9a-f-]{20,})/i] },
+  { key: 'twitter', names: ['Twitter', 'X API', '@Clawkit'], patterns: [/(?:Consumer|API)\s*Key.*?[:`]\s*`?([A-Za-z0-9]{20,})/i, /Bearer.*?[:`]\s*`?(AAAA[^\s`]+)/i] },
+  { key: 'stripe', names: ['Stripe'], patterns: [/(?:Secret|Publishable).*?[:`]\s*`?([sp]k_[^\s`]+)/i] },
+  { key: 'openai', names: ['OpenAI', 'Sora API'], patterns: [/(?:Key|API).*?[:`]\s*`?(sk-proj-[^\s`]+)/i, /(?:Key|API).*?[:`]\s*`?(sk-[^\s`]+)/i] },
+  { key: 'anthropic', names: ['Anthropic', 'Claude API'], patterns: [/(?:Key|API).*?[:`]\s*`?(sk-ant-[^\s`]+)/i] },
+  { key: 'brave_search', names: ['Brave Search', 'Brave API'], patterns: [/Brave.*(?:Key|API).*?[:`]\s*`?([^\s`]+)/i] },
   { key: 'telegram', names: ['Telegram'], patterns: [/Telegram.*(?:Token|Bot).*?[:`]\s*`?(\d+:[^\s`]+)/i] },
   { key: 'discord', names: ['Discord'], patterns: [/Discord.*(?:Token|Bot).*?[:`]\s*`?([^\s`]+)/i] },
-  { key: 'github', names: ['GitHub'], patterns: [/GitHub.*(?:Token|PAT).*?[:`]\s*`?(gh[pso]_[^\s`]+)/i] },
+  { key: 'github', names: ['GitHub'], patterns: [/GitHub.*(?:Token|PAT|User).*?[:`]\s*`?([^\s`]+)/i] },
+  { key: 'email', names: ['Email', 'IMAP', 'SMTP'], patterns: [/(?:Email|IMAP|SMTP).*?(?:address|account)?.*?[:`]\s*`?([^\s`]*@[^\s`]+)/i, /App Password.*?[:`]\s*`?([a-z ]{16,})/i] },
+  { key: 'sogni', names: ['Sogni'], patterns: [/SOGNI_USERNAME.*?[="`]\s*`?([^\s`"]+)/i] },
+  { key: 'upload_post', names: ['Upload-Post', 'upload-post'], patterns: [/upload-post.*?(?:Key|API).*?[:`]\s*`?(ey[^\s`]+)/i, /Authorization.*?Apikey\s+([^\s`]+)/i] },
+  { key: 'vercel', names: ['Vercel'], patterns: [/Vercel.*?(?:Token).*?[:`]\s*`?(vcp_[^\s`]+)/i] },
+  { key: 'netlify', names: ['Netlify'], patterns: [/Netlify.*?(?:Site|ID).*?[:`]\s*`?([0-9a-f-]{20,})/i] },
+  { key: 'maton', names: ['Maton', 'Google Workspace'], patterns: [/MATON_API_KEY.*?[:`]\s*`?([A-Za-z0-9_-]{30,})/i] },
 ];
 
 function parseAccountsFromTools(workspace) {
@@ -232,7 +239,75 @@ function gatherState(workspace) {
     }
   }
 
-  // Recent activity from daily notes
+  // --- Cron Jobs (from OpenClaw gateway API) ---
+  try {
+    // Try the local gateway WebSocket API via HTTP
+    const cronOut = execSync('curl -s -m 3 http://127.0.0.1:18789/api/cron/list 2>/dev/null || true', { timeout: 5000, encoding: 'utf8' });
+    const cronMatch = cronOut.match(/\{[\s\S]*\}/);
+    if (cronMatch) {
+      const cronData = JSON.parse(cronMatch[0]);
+      const jobs = cronData.jobs || [];
+      state.cronJobs = jobs.map(j => ({
+        name: j.name || (j.payload?.text || '').slice(0, 40) || 'Unnamed',
+        schedule: j.schedule?.kind === 'cron' ? j.schedule.expr :
+                  j.schedule?.kind === 'every' ? `every ${Math.round((j.schedule.everyMs || 0) / 60000)}m` :
+                  j.schedule?.kind === 'at' ? `at ${j.schedule.at}` : 'unknown',
+        lastRun: j.state?.lastRunAtMs ? new Date(j.state.lastRunAtMs).toISOString() : undefined,
+        status: j.state?.lastStatus || (j.enabled ? 'ok' : 'disabled'),
+      }));
+    }
+  } catch {}
+
+  // Fallback: parse cron info from HEARTBEAT.md
+  if (state.cronJobs.length === 0) {
+    const hbPath = join(workspace, 'HEARTBEAT.md');
+    if (existsSync(hbPath)) {
+      const hb = readFileSync(hbPath, 'utf8');
+      const tasks = hb.match(/\*\*(?:Task|Check):\*\*\s*(.+)/g) || [];
+      for (const t of tasks.slice(0, 8)) {
+        state.cronJobs.push({
+          name: t.replace(/\*\*(?:Task|Check):\*\*\s*/, '').slice(0, 50),
+          schedule: 'heartbeat',
+          status: 'ok',
+        });
+      }
+    }
+  }
+
+  // --- Recent Activity (real sources: git log, file changes, daily notes) ---
+
+  // Git log (last 10 commits from any repo in Desktop)
+  try {
+    const gitDirs = ['clawkit', 'clawkit-api', 'clawkit-package', 'dashboard'].map(d => join('/home', 'semo', 'Desktop', d));
+    for (const dir of gitDirs) {
+      if (!existsSync(join(dir, '.git'))) continue;
+      try {
+        const gitLog = execSync(`cd "${dir}" && git log --oneline --format="%ai|%s" -5 2>/dev/null`, { timeout: 3000, encoding: 'utf8' });
+        const repoName = dir.split('/').pop();
+        for (const line of gitLog.trim().split('\n').filter(Boolean)) {
+          const [date, ...msgParts] = line.split('|');
+          state.recentActivity.push({
+            timestamp: new Date(date.trim()).toISOString(),
+            message: `[${repoName}] ${msgParts.join('|').slice(0, 100)}`,
+          });
+        }
+      } catch {}
+    }
+  } catch {}
+
+  // Recent workspace file changes (last 24h)
+  try {
+    const recentFiles = execSync(`find "${workspace}" -name "*.md" -mmin -1440 -not -path "*/node_modules/*" -not -path "*/.git/*" -printf "%T@|%f\n" 2>/dev/null | sort -rn | head -5`, { timeout: 3000, encoding: 'utf8' });
+    for (const line of recentFiles.trim().split('\n').filter(Boolean)) {
+      const [ts, file] = line.split('|');
+      state.recentActivity.push({
+        timestamp: new Date(parseFloat(ts) * 1000).toISOString(),
+        message: `Updated ${file}`,
+      });
+    }
+  } catch {}
+
+  // Daily notes entries
   const today = new Date().toISOString().slice(0, 10);
   const yesterday = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
   for (const day of [today, yesterday]) {
@@ -242,7 +317,7 @@ function gatherState(workspace) {
       if (existsSync(f)) {
         const lines = readFileSync(f, 'utf8').split('\n')
           .filter(l => l.startsWith('- ') || l.startsWith('* '))
-          .slice(0, 5);
+          .slice(0, 3);
         for (const line of lines) {
           state.recentActivity.push({
             timestamp: `${day}T12:00:00Z`,
@@ -252,7 +327,62 @@ function gatherState(workspace) {
       }
     }
   }
-  state.recentActivity = state.recentActivity.slice(0, 15);
+
+  // Sort by timestamp descending, dedupe, limit
+  state.recentActivity.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  state.recentActivity = state.recentActivity.slice(0, 20);
+
+  // --- Token Usage & Cost ---
+  state.usage = { inputTokens: 0, outputTokens: 0, contextUsed: 0, contextMax: 0, costEstimate: '', model: '', compactions: 0 };
+
+  // Try to read from OpenClaw gateway config for model
+  try {
+    const gwConfig = join(process.env.HOME || '', '.openclaw', 'config.yaml');
+    if (existsSync(gwConfig)) {
+      const cfg = readFileSync(gwConfig, 'utf8');
+      const modelMatch = cfg.match(/model:\s*["']?([^\s"']+)/);
+      if (modelMatch) state.usage.model = modelMatch[1];
+    }
+  } catch {}
+
+  // Try to get session stats from gateway HTTP API
+  try {
+    const statusOut = execSync('curl -s -m 3 http://127.0.0.1:18789/api/session/status 2>/dev/null || true', { timeout: 5000, encoding: 'utf8' });
+    const statusMatch = statusOut.match(/\{[\s\S]*\}/);
+    if (statusMatch) {
+      const sd = JSON.parse(statusMatch[0]);
+      if (sd.inputTokens || sd.tokensIn) state.usage.inputTokens = sd.inputTokens || sd.tokensIn || 0;
+      if (sd.outputTokens || sd.tokensOut) state.usage.outputTokens = sd.outputTokens || sd.tokensOut || 0;
+      if (sd.contextUsed) state.usage.contextUsed = sd.contextUsed;
+      if (sd.contextMax) state.usage.contextMax = sd.contextMax;
+      if (sd.compactions) state.usage.compactions = sd.compactions;
+      if (sd.model) state.usage.model = sd.model;
+    }
+  } catch {}
+
+  // If we couldn't get from CLI, estimate from daily note sizes
+  if (!state.usage.model) {
+    state.usage.model = state.preferences.defaultModel || 'unknown';
+  }
+
+  // Cost estimation based on model
+  const MODEL_COSTS = {
+    'claude-opus-4-6': { input: 15, output: 75 },     // per 1M tokens
+    'claude-opus-4': { input: 15, output: 75 },
+    'claude-sonnet-4-5': { input: 3, output: 15 },
+    'claude-sonnet-4': { input: 3, output: 15 },
+    'claude-haiku-3-5': { input: 0.8, output: 4 },
+    'gpt-4o': { input: 2.5, output: 10 },
+    'gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'gemini-2.0-flash': { input: 0.1, output: 0.4 },
+  };
+  const modelKey = Object.keys(MODEL_COSTS).find(k => state.usage.model?.includes(k));
+  const costs = MODEL_COSTS[modelKey] || { input: 3, output: 15 };
+  const inCost = (state.usage.inputTokens / 1_000_000) * costs.input;
+  const outCost = (state.usage.outputTokens / 1_000_000) * costs.output;
+  state.usage.costEstimate = `$${(inCost + outCost).toFixed(4)}`;
+  state.usage.costPerMInput = costs.input;
+  state.usage.costPerMOutput = costs.output;
 
   return state;
 }