@vibe-cafe/vibe-usage 0.7.11 → 0.7.13

package/README.md

@@ -59,6 +59,9 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
+| Kiro | `~/Library/Application Support/Kiro/User/globalStorage/kiro.kiroagent/dev_data/devdata.sqlite` (SQLite, JSONL fallback; model name resolved from `.chat` timeline) |
+| Cline | `<host>/User/globalStorage/saoudrizwan.claude-dev/{state/taskHistory.json,tasks/<id>/ui_messages.json}` (walks all VSCode-fork hosts: Code, Cursor, Windsurf, VSCodium, Trae, ...) |
+| Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
 
 ## How It Works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {

package/src/parsers/cline.js

@@ -0,0 +1,116 @@
+import { readFileSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const EXTENSION_ID = 'saoudrizwan.claude-dev';
+
+// VSCode-fork application names that may host extensions.
+const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
+
+function getHostRoots() {
+  const out = [];
+  if (process.platform === 'darwin') {
+    const base = join(homedir(), 'Library', 'Application Support');
+    for (const h of HOSTS) out.push(join(base, h));
+  } else if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    for (const h of HOSTS) out.push(join(appData, h));
+  } else {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    for (const h of HOSTS) out.push(join(xdg, h));
+  }
+  return out;
+}
+
+export function findClineExtensionDirs() {
+  const dirs = [];
+  for (const root of getHostRoots()) {
+    const ext = join(root, 'User', 'globalStorage', EXTENSION_ID);
+    try {
+      if (statSync(ext).isDirectory()) dirs.push(ext);
+    } catch {
+      // not installed in this host; skip
+    }
+  }
+  return dirs;
+}
+
+function readJsonSafe(path) {
+  try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return null; }
+}
+
+function projectFromPath(absPath) {
+  if (!absPath || typeof absPath !== 'string') return 'unknown';
+  const trimmed = absPath.replace(/[\\/]+$/, '');
+  const name = basename(trimmed);
+  return name || 'unknown';
+}
+
+export async function parse() {
+  const extDirs = findClineExtensionDirs();
+  if (extDirs.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const events = [];
+
+  for (const extDir of extDirs) {
+    const history = readJsonSafe(join(extDir, 'state', 'taskHistory.json'));
+    if (!Array.isArray(history)) continue;
+
+    for (const item of history) {
+      try {
+        if (!item || typeof item !== 'object' || !item.id) continue;
+        const taskId = String(item.id);
+        const project = projectFromPath(item.cwdOnTaskInitialization || item.shadowGitConfigWorkTree);
+        const fallbackModel = (item.modelId && String(item.modelId).trim()) || 'cline-unknown';
+
+        const messages = readJsonSafe(join(extDir, 'tasks', taskId, 'ui_messages.json'));
+        if (!Array.isArray(messages)) continue;
+
+        for (const msg of messages) {
+          if (!msg || typeof msg !== 'object') continue;
+          const ts = Number(msg.ts);
+          if (!Number.isFinite(ts)) continue;
+          const timestamp = new Date(ts);
+
+          if (msg.type === 'say' && msg.say === 'api_req_started') {
+            let info = null;
+            try { info = JSON.parse(msg.text); } catch { /* skip */ }
+            if (!info) continue;
+
+            const inputTokens = Math.max(0, Number(info.tokensIn) || 0);
+            const outputTokens = Math.max(0, Number(info.tokensOut) || 0);
+            const cacheWrites = Math.max(0, Number(info.cacheWrites) || 0);
+            const cacheReads = Math.max(0, Number(info.cacheReads) || 0);
+            if (inputTokens + outputTokens + cacheWrites + cacheReads === 0) continue;
+
+            // Newer Cline embeds the model id directly on the api_req_started payload.
+            const model = (info.model && String(info.model).trim()) || fallbackModel;
+
+            // Bucket schema (matches Cursor's CSV semantics):
+            //   inputTokens       = non-cache input + cache-write tokens (both billed as input)
+            //   cachedInputTokens = cache-read tokens (10% input rate)
+            entries.push({
+              source: 'cline',
+              model,
+              project,
+              timestamp,
+              inputTokens: inputTokens + cacheWrites,
+              outputTokens,
+              cachedInputTokens: cacheReads,
+              reasoningOutputTokens: 0,
+            });
+            events.push({ sessionId: taskId, source: 'cline', project, timestamp, role: 'assistant' });
+          } else if (msg.type === 'ask' || (msg.type === 'say' && msg.say === 'user_feedback')) {
+            events.push({ sessionId: taskId, source: 'cline', project, timestamp, role: 'user' });
+          }
+        }
+      } catch {
+        // Skip this task; keep going for the rest of the history.
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
+}

package/src/parsers/index.js

@@ -1,8 +1,10 @@
 import { createHash } from 'node:crypto';
 import { parse as parseClaudeCode } from './claude-code.js';
+import { parse as parseCline } from './cline.js';
 import { parse as parseCodex } from './codex.js';
 import { parse as parseCopilotCli } from './copilot-cli.js';
 import { parse as parseCursor } from './cursor.js';
+import { parse as parseRooCode } from './roo-code.js';
 import { parse as parseGeminiCli } from './gemini-cli.js';
 import { parse as parseOpencode } from './opencode.js';
 import { parse as parseOpenclaw } from './openclaw.js';
@@ -12,13 +14,16 @@ import { parse as parseAmp } from './amp.js';
 import { parse as parseDroid } from './droid.js';
 import { parse as parseAntigravity } from './antigravity.js';
 import { parse as parseHermes } from './hermes.js';
+import { parse as parseKiro } from './kiro.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
+  'cline': parseCline,
   'codex': parseCodex,
   'copilot-cli': parseCopilotCli,
   'cursor': parseCursor,
+  'roo-code': parseRooCode,
   'gemini-cli': parseGeminiCli,
   'opencode': parseOpencode,
   'openclaw': parseOpenclaw,
@@ -28,6 +33,7 @@ export const parsers = {
   'droid': parseDroid,
   'antigravity': parseAntigravity,
   'hermes': parseHermes,
+  'kiro': parseKiro,
   'pi-coding-agent': parsePiCodingAgent,
 };
 

package/src/parsers/kiro.js

@@ -0,0 +1,238 @@
+import { execFileSync } from 'node:child_process';
+import {
+  copyFileSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+} from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { aggregateToBuckets } from './index.js';
+
+const KIROAGENT_RELATIVE = join('User', 'globalStorage', 'kiro.kiroagent');
+
+function getDefaultBasePath() {
+  if (process.platform === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Kiro', KIROAGENT_RELATIVE);
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    return join(appData, 'Kiro', KIROAGENT_RELATIVE);
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+  return join(xdgConfigHome, 'Kiro', KIROAGENT_RELATIVE);
+}
+
+export function getKiroBasePath() {
+  const explicit = process.env.KIRO_BASE_PATH?.trim();
+  if (explicit) {
+    const r = resolve(explicit);
+    return existsSync(r) ? r : null;
+  }
+  const def = getDefaultBasePath();
+  return existsSync(def) ? def : null;
+}
+
+function isLockError(err) {
+  return err && typeof err.message === 'string' && /database is locked/i.test(err.message);
+}
+
+function queryDb(dbPath, sql) {
+  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
+    encoding: 'utf-8',
+    maxBuffer: 100 * 1024 * 1024,
+    timeout: 30000,
+  });
+  const trimmed = out.trim();
+  if (!trimmed || trimmed === '[]') return [];
+  return JSON.parse(trimmed);
+}
+
+const TOKENS_SQL =
+  'SELECT id, model, tokens_prompt, tokens_generated, timestamp ' +
+  'FROM tokens_generated ' +
+  'WHERE tokens_prompt > 0 OR tokens_generated > 0 ' +
+  'ORDER BY id ASC';
+
+function readDb(dbPath) {
+  try {
+    return queryDb(dbPath, TOKENS_SQL);
+  } catch (err) {
+    if (!isLockError(err)) throw err;
+    // Kiro app holds a write lock; snapshot WAL set to a temp dir and retry.
+    const snapshotDir = mkdtempSync(join(tmpdir(), 'vibe-usage-kiro-'));
+    const queryPath = join(snapshotDir, 'devdata.sqlite');
+    copyFileSync(dbPath, queryPath);
+    for (const suffix of ['-shm', '-wal']) {
+      const companion = `${dbPath}${suffix}`;
+      if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
+    }
+    try {
+      return queryDb(queryPath, TOKENS_SQL);
+    } finally {
+      rmSync(snapshotDir, { recursive: true, force: true });
+    }
+  }
+}
+
+// JSONL fallback: tokens_generated.jsonl. Each line:
+// {"model":"agent","provider":"kiro","promptTokens":N,"generatedTokens":N}
+// No per-row timestamp — bucket all rows under the file mtime.
+function readJsonl(jsonlPath) {
+  let raw;
+  try { raw = readFileSync(jsonlPath, 'utf-8'); } catch { return []; }
+  const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+  if (lines.length === 0) return [];
+  let mtime;
+  try { mtime = statSync(jsonlPath).mtime; } catch { mtime = new Date(); }
+  const ts = mtime.toISOString().replace('T', ' ').replace('Z', '').slice(0, 19);
+  const rows = [];
+  for (let i = 0; i < lines.length; i++) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      rows.push({
+        id: i + 1,
+        model: obj.model || 'agent',
+        tokens_prompt: obj.promptTokens || 0,
+        tokens_generated: obj.generatedTokens || 0,
+        timestamp: ts,
+      });
+    } catch {
+      // skip malformed lines
+    }
+  }
+  return rows;
+}
+
+// Walk workspace dirs under kiro.kiroagent/ and collect every .chat file's
+// modelId + start/end window. Used to attribute each tokens_generated row to
+// a real model (the SQLite `model` column is usually the literal "agent").
+function buildModelTimeline(base) {
+  const timeline = [];
+  let entries;
+  try { entries = readdirSync(base, { withFileTypes: true }); } catch { return timeline; }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === 'dev_data') continue;
+    const dirPath = join(base, entry.name);
+    let files;
+    try {
+      files = readdirSync(dirPath).filter(f => f.endsWith('.chat'));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(dirPath, file), 'utf-8'));
+        const meta = data?.metadata;
+        if (!meta?.modelId || !meta?.startTime) continue;
+        const startMs = Number(meta.startTime);
+        const endMs = Number(meta.endTime || meta.startTime);
+        if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) continue;
+        timeline.push({ startMs, endMs, model: String(meta.modelId) });
+      } catch {
+        // skip unreadable / malformed chat files
+      }
+    }
+  }
+  timeline.sort((a, b) => a.startMs - b.startMs);
+  return timeline;
+}
+
+function resolveModel(timeline, ts) {
+  if (!timeline.length || !ts) return null;
+  const t = ts.getTime();
+  if (!Number.isFinite(t)) return null;
+  let best = null;
+  let bestDist = Infinity;
+  for (const e of timeline) {
+    if (t >= e.startMs && t <= e.endMs) return e.model;
+    const d = Math.min(Math.abs(t - e.startMs), Math.abs(t - e.endMs));
+    if (d < bestDist) { bestDist = d; best = e.model; }
+  }
+  // 10-minute tolerance — beyond that, treat as no match.
+  return bestDist < 10 * 60 * 1000 ? best : null;
+}
+
+// "CLAUDE_SONNET_4_20250514_V1_0" -> "claude-sonnet-4"
+function normalizeModelName(raw) {
+  if (!raw || typeof raw !== 'string') return null;
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed === trimmed.toLowerCase() && trimmed.includes('-')) return trimmed;
+  const cleaned = trimmed
+    .replace(/_\d{8}_V\d+_\d+$/i, '')
+    .replace(/_V\d+$/i, '')
+    .toLowerCase()
+    .replace(/_/g, '-');
+  return cleaned || null;
+}
+
+function parseDbTimestamp(value) {
+  if (!value) return null;
+  // SQLite CURRENT_TIMESTAMP: "2026-01-09 15:25:30" (UTC, naive — append Z).
+  const d = new Date(String(value).trim().replace(' ', 'T') + 'Z');
+  return isNaN(d.getTime()) ? null : d;
+}
+
+export async function parse() {
+  const base = getKiroBasePath();
+  if (!base) return { buckets: [], sessions: [] };
+
+  const dbPath = join(base, 'dev_data', 'devdata.sqlite');
+  const jsonlPath = join(base, 'dev_data', 'tokens_generated.jsonl');
+
+  let rows;
+  try {
+    if (existsSync(dbPath)) {
+      rows = readDb(dbPath);
+    } else if (existsSync(jsonlPath)) {
+      rows = readJsonl(jsonlPath);
+    } else {
+      return { buckets: [], sessions: [] };
+    }
+  } catch (err) {
+    if (err && typeof err.message === 'string' && err.message.includes('ENOENT')) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Kiro data.');
+    }
+    throw err;
+  }
+
+  if (!rows.length) return { buckets: [], sessions: [] };
+
+  const timeline = buildModelTimeline(base);
+  const entries = [];
+  for (const row of rows) {
+    const inputTokens = Math.max(0, Number(row.tokens_prompt) || 0);
+    const outputTokens = Math.max(0, Number(row.tokens_generated) || 0);
+    if (inputTokens === 0 && outputTokens === 0) continue;
+    const timestamp = parseDbTimestamp(row.timestamp);
+    if (!timestamp) continue;
+
+    // Prefer the .chat timeline; fall back to the row's literal model (skip
+    // the placeholder "agent"); then "kiro-agent".
+    let model = normalizeModelName(resolveModel(timeline, timestamp));
+    if (!model) {
+      const literal = (row.model || '').trim();
+      if (literal && literal.toLowerCase() !== 'agent') {
+        model = normalizeModelName(literal);
+      }
+    }
+    if (!model) model = 'kiro-agent';
+
+    entries.push({
+      source: 'kiro',
+      model,
+      project: 'unknown',
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens: 0,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: [] };
+}

package/src/parsers/roo-code.js

@@ -0,0 +1,133 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const EXTENSION_ID = 'rooveterinaryinc.roo-cline';
+
+const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
+
+function getHostRoots() {
+  const out = [];
+  if (process.platform === 'darwin') {
+    const base = join(homedir(), 'Library', 'Application Support');
+    for (const h of HOSTS) out.push(join(base, h));
+  } else if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    for (const h of HOSTS) out.push(join(appData, h));
+  } else {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    for (const h of HOSTS) out.push(join(xdg, h));
+  }
+  return out;
+}
+
+export function findRooCodeExtensionDirs() {
+  const dirs = [];
+  for (const root of getHostRoots()) {
+    const ext = join(root, 'User', 'globalStorage', EXTENSION_ID);
+    try {
+      if (statSync(ext).isDirectory()) dirs.push(ext);
+    } catch {
+      // not installed in this host; skip
+    }
+  }
+  return dirs;
+}
+
+function readJsonSafe(path) {
+  try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return null; }
+}
+
+function projectFromPath(absPath) {
+  if (!absPath || typeof absPath !== 'string') return 'unknown';
+  const trimmed = absPath.replace(/[\\/]+$/, '');
+  const name = basename(trimmed);
+  return name || 'unknown';
+}
+
+// Read all HistoryItems from `_index.json` if present, else fall back to
+// scanning per-task `history_item.json` files (Roo migrated to per-task
+// files in 2025; the index is a cache).
+function readHistoryItems(extDir) {
+  const tasksDir = join(extDir, 'tasks');
+  const indexPath = join(tasksDir, '_index.json');
+  const index = readJsonSafe(indexPath);
+  if (index && Array.isArray(index.entries)) return index.entries;
+
+  const items = [];
+  let names;
+  try { names = readdirSync(tasksDir, { withFileTypes: true }); } catch { return items; }
+  for (const entry of names) {
+    if (!entry.isDirectory() || entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+    const item = readJsonSafe(join(tasksDir, entry.name, 'history_item.json'));
+    if (item && typeof item === 'object') items.push(item);
+  }
+  return items;
+}
+
+export async function parse() {
+  const extDirs = findRooCodeExtensionDirs();
+  if (extDirs.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const events = [];
+
+  for (const extDir of extDirs) {
+    const items = readHistoryItems(extDir);
+    if (!items.length) continue;
+
+    for (const item of items) {
+      try {
+        if (!item || typeof item !== 'object' || !item.id) continue;
+        const taskId = String(item.id);
+        const project = projectFromPath(item.workspace);
+        // Roo doesn't store modelId; the profile name (apiConfigName) is the
+        // best fallback — users typically name profiles after the model.
+        const fallbackModel = (item.apiConfigName && String(item.apiConfigName).trim()) || 'roo-unknown';
+
+        const messages = readJsonSafe(join(extDir, 'tasks', taskId, 'ui_messages.json'));
+        if (!Array.isArray(messages)) continue;
+
+        for (const msg of messages) {
+          if (!msg || typeof msg !== 'object') continue;
+          const ts = Number(msg.ts);
+          if (!Number.isFinite(ts)) continue;
+          const timestamp = new Date(ts);
+
+          if (msg.type === 'say' && msg.say === 'api_req_started') {
+            let info = null;
+            try { info = JSON.parse(msg.text); } catch { /* skip */ }
+            if (!info) continue;
+
+            const inputTokens = Math.max(0, Number(info.tokensIn) || 0);
+            const outputTokens = Math.max(0, Number(info.tokensOut) || 0);
+            const cacheWrites = Math.max(0, Number(info.cacheWrites) || 0);
+            const cacheReads = Math.max(0, Number(info.cacheReads) || 0);
+            if (inputTokens + outputTokens + cacheWrites + cacheReads === 0) continue;
+
+            const model = (info.model && String(info.model).trim()) || fallbackModel;
+
+            entries.push({
+              source: 'roo-code',
+              model,
+              project,
+              timestamp,
+              inputTokens: inputTokens + cacheWrites,
+              outputTokens,
+              cachedInputTokens: cacheReads,
+              reasoningOutputTokens: 0,
+            });
+            events.push({ sessionId: taskId, source: 'roo-code', project, timestamp, role: 'assistant' });
+          } else if (msg.type === 'ask' || (msg.type === 'say' && msg.say === 'user_feedback')) {
+            events.push({ sessionId: taskId, source: 'roo-code', project, timestamp, role: 'user' });
+          }
+        }
+      } catch {
+        // Skip this task; keep going for the rest of the history.
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
+}

package/src/sync.js

@@ -89,6 +89,8 @@ export async function runSync({ throws = false, quiet = false } = {}) {
 
   let totalIngested = 0;
   let totalSessionsSynced = 0;
+  let totalDroppedBuckets = 0;
+  const droppedSources = new Set();
   const bucketBatches = Math.ceil(allBuckets.length / BATCH_SIZE);
   const sessionBatches = Math.ceil(allSessions.length / SESSION_BATCH_SIZE);
   const totalBatches = Math.max(bucketBatches, sessionBatches, 1);
@@ -108,6 +110,10 @@ export async function runSync({ throws = false, quiet = false } = {}) {
       }, batchSessions.length > 0 ? batchSessions : undefined);
       totalIngested += result.ingested ?? batch.length;
       totalSessionsSynced += result.sessions ?? 0;
+      if (result.dropped) {
+        totalDroppedBuckets += Number(result.dropped.buckets) || 0;
+        for (const s of result.dropped.unknownSources || []) droppedSources.add(s);
+      }
     }
 
     if (totalBatches > 1 || allBuckets.length > 0) {
@@ -117,6 +123,14 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     if (totalSessionsSynced > 0) syncParts.push(`${totalSessionsSynced} sessions`);
     console.log(success(`已同步 ${syncParts.join(' · ')}`));
 
+    if (totalDroppedBuckets > 0) {
+      // Server doesn't (yet) recognize these source IDs — usually means the
+      // CLI is newer than the deployed vibe-cafe. Surface so the user knows
+      // the data wasn't lost on their end, just not stored upstream.
+      const sourcesList = Array.from(droppedSources).sort().join(', ');
+      console.log(dim(`  ${totalDroppedBuckets} buckets dropped (服务端未收录的 source: ${sourcesList})`));
+    }
+
     if (!quiet && totalSessionsSynced > 0) {
       const totalActive = allSessions.reduce((s, x) => s + x.activeSeconds, 0);
       const totalDuration = allSessions.reduce((s, x) => s + x.durationSeconds, 0);

package/src/tools.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
@@ -15,6 +15,53 @@ function getCursorStateDbPath() {
   return join(xdgConfigHome, 'Cursor', rel);
 }
 
+function getKiroAgentPath() {
+  const rel = join('User', 'globalStorage', 'kiro.kiroagent');
+  if (process.platform === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Kiro', rel);
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    return join(appData, 'Kiro', rel);
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+  return join(xdgConfigHome, 'Kiro', rel);
+}
+
+// VSCode-fork host directories where extensions like Cline / Roo Code live.
+const VSCODE_HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
+
+function getVscodeHostRoots() {
+  const out = [];
+  if (process.platform === 'darwin') {
+    const base = join(homedir(), 'Library', 'Application Support');
+    for (const h of VSCODE_HOSTS) out.push(join(base, h));
+  } else if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    for (const h of VSCODE_HOSTS) out.push(join(appData, h));
+  } else {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    for (const h of VSCODE_HOSTS) out.push(join(xdg, h));
+  }
+  return out;
+}
+
+function findExtensionDirs(extensionId) {
+  const dirs = [];
+  for (const root of getVscodeHostRoots()) {
+    const ext = join(root, 'User', 'globalStorage', extensionId);
+    try {
+      if (statSync(ext).isDirectory()) dirs.push(ext);
+    } catch {
+      // not present in this host
+    }
+  }
+  return dirs;
+}
+
+const findClineDataDirs = () => findExtensionDirs('saoudrizwan.claude-dev');
+const findRooCodeDataDirs = () => findExtensionDirs('rooveterinaryinc.roo-cline');
+
 /** Find all OpenClaw data roots: ~/.openclaw and ~/.openclaw-<profile> */
 function findOpenclawDataDirs() {
   const home = homedir();
@@ -44,6 +91,12 @@ export const TOOLS = [
     id: 'claude-code',
     dataDir: join(homedir(), '.claude', 'projects'),
   },
+  {
+    name: 'Cline',
+    id: 'cline',
+    dataDir: join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+    detectDataDirs: findClineDataDirs,
+  },
   {
     name: 'Codex CLI',
     id: 'codex',
@@ -105,6 +158,17 @@ export const TOOLS = [
     id: 'hermes',
     dataDir: join(homedir(), '.hermes', 'state.db'),
   },
+  {
+    name: 'Kiro',
+    id: 'kiro',
+    dataDir: getKiroAgentPath(),
+  },
+  {
+    name: 'Roo Code',
+    id: 'roo-code',
+    dataDir: join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline'),
+    detectDataDirs: findRooCodeDataDirs,
+  },
 ];
 
 export function detectInstalledTools() {