@juliantanx/aiusage 1.5.1 → 1.5.2

package/dist/index.js

@@ -8,19 +8,21 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/cli.ts
 import { Command } from "commander";
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import { execSync as execSync5 } from "child_process";
 
 // src/commands/serve.ts
 import http2 from "http";
-import { readFileSync as readFileSync8, existsSync as existsSync9, statSync as statSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join10, extname as extname2, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync10, statSync as statSync3, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3 } from "fs";
+import { join as join11, extname as extname2, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 
 // src/api/server.ts
 import http from "http";
-import { hostname, platform as platform3 } from "os";
+import path2 from "path";
+import { hostname, platform as platform3, tmpdir } from "os";
 import { randomBytes as randomBytes3 } from "crypto";
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync4 } from "fs";
 
 // ../core/dist/index.js
 import { createHash } from "crypto";
@@ -33,6 +35,7 @@ var TOOLS = [
   "qoder",
   "cursor",
   "kilocode",
+  "kelivo",
   "copilot",
   "gemini",
   "kimi",
@@ -1720,6 +1723,13 @@ function probeKiloTasks(ctx) {
   }
   return null;
 }
+function probeKelivo(ctx) {
+  const override = envOverride("kelivo", ctx.env);
+  if (override) return override;
+  const legacy = ctx.legacySources?.["kelivo"];
+  if (legacy) return legacy;
+  return null;
+}
 function probeCopilot(ctx) {
   const override = envOverride("copilot", ctx.env);
   if (override) return override;
@@ -1905,6 +1915,7 @@ var TOOL_REGISTRY = [
   { tool: "cursor", sourceKey: "cursor", label: "Cursor", probe: probeCursor },
   { tool: "kilocode", sourceKey: "kilocode", label: "Kilo Code (extension)", probe: probeKiloTasks },
   { tool: "kilocode", sourceKey: "kilocode-db", label: "KiloCode", probe: probeKiloDb },
+  { tool: "kelivo", sourceKey: "kelivo", label: "Kelivo", probe: probeKelivo },
   { tool: "copilot", sourceKey: "copilot", label: "Copilot", probe: probeCopilot },
   { tool: "gemini", sourceKey: "gemini", label: "Gemini CLI", probe: probeGemini },
   { tool: "kimi", sourceKey: "kimi", label: "Kimi Code", probe: probeKimi },
@@ -1926,11 +1937,11 @@ function discoverTools(env = process.env) {
   const legacySources = config?.sources;
   const ctx = { home, env, legacySources };
   return TOOL_REGISTRY.map((entry) => {
-    const path2 = entry.probe(ctx);
-    if (!path2) {
+    const path3 = entry.probe(ctx);
+    if (!path3) {
       return { tool: entry.tool, sourceKey: entry.sourceKey, label: entry.label, path: "", fileCount: 0, status: "not_found" };
     }
-    const detectedPaths = entry.sourceKey === "opencode" && !envOverride("opencode", env) && !env.OPENCODE_DB && !legacySources?.["opencode"] ? existingOpenCodeDbs(env).filter((dbPath) => existsSync3(dbPath)) : entry.sourceKey === "codex" ? codexLogDirs(ctx, path2) : [path2];
+    const detectedPaths = entry.sourceKey === "opencode" && !envOverride("opencode", env) && !env.OPENCODE_DB && !legacySources?.["opencode"] ? existingOpenCodeDbs(env).filter((dbPath) => existsSync3(dbPath)) : entry.sourceKey === "codex" ? codexLogDirs(ctx, path3) : [path3];
     let fileCount = 0;
     for (const detectedPath of detectedPaths) {
       try {
@@ -1938,6 +1949,8 @@ function discoverTools(env = process.env) {
         if (stat2.isDirectory()) {
           if (entry.sourceKey === "roocode" || entry.sourceKey === "kilocode") {
             fileCount += findJsonFiles(detectedPath).filter((p) => basename(p) === "ui_messages.json").length;
+          } else if (entry.sourceKey === "kelivo") {
+            fileCount += findJsonFiles(detectedPath).filter((p) => basename(p) === "chats.json").length + findZipFiles(detectedPath).length;
           } else if (entry.sourceKey === "kiro") {
             fileCount += unique([...findJsonlFiles(detectedPath), ...findJsonFiles(detectedPath)]).length;
           } else {
@@ -1955,7 +1968,7 @@ function discoverTools(env = process.env) {
       tool: entry.tool,
       sourceKey: entry.sourceKey,
       label: entry.label,
-      path: path2,
+      path: path3,
       paths: visiblePaths.length > 1 || entry.sourceKey === "codex" && visiblePaths.length > 0 ? visiblePaths : void 0,
       fileCount,
       status
@@ -2057,6 +2070,11 @@ function discoverLogFiles(env = process.env) {
     const paths = findJsonFiles(kilocodeTaskPath).filter((p) => basename(p) === "ui_messages.json");
     if (paths.length > 0) results.push({ tool: "kilocode", paths: unique(paths) });
   }
+  const kelivoPath = probeKelivo(ctx);
+  if (kelivoPath && existsSync3(kelivoPath)) {
+    const paths = statSync(kelivoPath).isDirectory() ? [...findJsonFiles(kelivoPath).filter((p) => basename(p) === "chats.json"), ...findZipFiles(kelivoPath)] : basename(kelivoPath) === "chats.json" || basename(kelivoPath).endsWith(".zip") ? [kelivoPath] : [];
+    if (paths.length > 0) results.push({ tool: "kelivo", paths: unique(paths) });
+  }
   return results;
 }
 function findJsonFiles(dir) {
@@ -2075,6 +2093,22 @@ function findJsonFiles(dir) {
   }
   return results;
 }
+function findZipFiles(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findZipFiles(fullPath));
+      } else if (entry.isFile() && extname(entry.name) === ".zip") {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
 function normalizeQoderPath(source) {
   const normalized = source.replace(/\\/g, "/").replace(/\/+$/, "");
   if (normalized.endsWith("/logs/sessions") || normalized.endsWith("/sessions") || normalized.endsWith("/segments")) {
@@ -2594,8 +2628,8 @@ function generateNonce() {
 function generateIdempotencyKey() {
   return randomBytes(16).toString("hex");
 }
-function buildCanonicalString(method, path2, bodyHash, timestamp, nonce, deviceId, idempotencyKey) {
-  return [method, path2, bodyHash, timestamp, nonce, deviceId, idempotencyKey].join("\n");
+function buildCanonicalString(method, path3, bodyHash, timestamp, nonce, deviceId, idempotencyKey) {
+  return [method, path3, bodyHash, timestamp, nonce, deviceId, idempotencyKey].join("\n");
 }
 function base64url(data) {
   const buf = typeof data === "string" ? Buffer.from(data) : data;
@@ -2668,8 +2702,8 @@ async function readJsonOrNull(response) {
   if (!contentType.includes("application/json")) return null;
   return response.json().catch(() => null);
 }
-function endpointUnavailableMessage(path2, status) {
-  return `Leaderboard API endpoint ${path2} is unavailable (HTTP ${status}). The site deployment is not routing this API request to the Node server.`;
+function endpointUnavailableMessage(path3, status) {
+  return `Leaderboard API endpoint ${path3} is unavailable (HTTP ${status}). The site deployment is not routing this API request to the Node server.`;
 }
 async function fetchLeaderboard(serverUrl, options = {}) {
   const params = new URLSearchParams();
@@ -3164,9 +3198,9 @@ function initializeDatabase(db) {
   applyPragmas(db);
   runMigrations(db);
 }
-function createDatabase(path2) {
-  mkdirSync3(dirname2(path2), { recursive: true, mode: 448 });
-  const db = new Database(path2);
+function createDatabase(path3) {
+  mkdirSync3(dirname2(path3), { recursive: true, mode: 448 });
+  const db = new Database(path3);
   initializeDatabase(db);
   return db;
 }
@@ -3364,10 +3398,10 @@ function getClientPlatform() {
 }
 function getCliVersion() {
   try {
-    const { readFileSync: readFileSync11 } = __require("fs");
+    const { readFileSync: readFileSync12 } = __require("fs");
     const { join: join16 } = __require("path");
     const pkgPath = join16(__dirname, "../../package.json");
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -3645,8 +3679,273 @@ Summary: ${accepted} accepted, ${flagged} flagged, ${rejected} rejected`);
   }
 }
 
+// src/commands/parse-kelivo.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { basename as basename2 } from "path";
+import * as yauzl from "yauzl";
+function toTokenCount(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+function parseTimestamp(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return value < 1e12 ? value * 1e3 : value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = new Date(value).getTime();
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+async function readZipEntryText(filePath, entryName) {
+  return new Promise((resolve2, reject) => {
+    yauzl.open(filePath, { lazyEntries: true }, (openError, zipfile) => {
+      if (openError) {
+        reject(openError);
+        return;
+      }
+      if (!zipfile) {
+        reject(new Error("Unable to open zip file"));
+        return;
+      }
+      let settled = false;
+      zipfile.readEntry();
+      zipfile.on("entry", (entry) => {
+        if (basename2(entry.fileName) !== entryName) {
+          zipfile.readEntry();
+          return;
+        }
+        zipfile.openReadStream(entry, (streamError, stream) => {
+          if (streamError) {
+            settled = true;
+            zipfile.close();
+            reject(streamError);
+            return;
+          }
+          if (!stream) {
+            settled = true;
+            zipfile.close();
+            reject(new Error(`Missing ${entryName} stream`));
+            return;
+          }
+          const chunks = [];
+          stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+          stream.on("error", (e) => {
+            settled = true;
+            zipfile.close();
+            reject(e);
+          });
+          stream.on("end", () => {
+            settled = true;
+            zipfile.close();
+            resolve2(Buffer.concat(chunks).toString("utf-8"));
+          });
+        });
+      });
+      zipfile.on("end", () => {
+        if (!settled) reject(new Error(`${entryName} not found in zip`));
+      });
+      zipfile.on("error", (e) => {
+        if (!settled) reject(e);
+      });
+    });
+  });
+}
+async function readKelivoExport(filePath) {
+  const text = filePath.endsWith(".zip") ? await readZipEntryText(filePath, "chats.json") : readFileSync6(filePath, "utf-8");
+  return JSON.parse(text);
+}
+async function runParseKelivo(options) {
+  const { filePath, device, deviceInstanceId, platform: platform5, now, exchangeRate } = options;
+  const records = [];
+  const errors = [];
+  let parsed;
+  try {
+    parsed = await readKelivoExport(filePath);
+  } catch (e) {
+    return { records, errors: [`${filePath}: ${e instanceof Error ? e.message : e}`] };
+  }
+  const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+  for (const [index, message] of messages.entries()) {
+    if (message?.role !== "assistant") continue;
+    const promptTokens = toTokenCount(message.promptTokens);
+    const completionTokens = toTokenCount(message.completionTokens);
+    const cachedTokens = toTokenCount(message.cachedTokens);
+    const totalTokens = toTokenCount(message.totalTokens);
+    const inputTokens = promptTokens > 0 ? Math.max(0, promptTokens - cachedTokens) : Math.max(0, totalTokens - completionTokens - cachedTokens);
+    const outputTokens = completionTokens;
+    const cacheReadTokens = cachedTokens;
+    const cacheWriteTokens = 0;
+    const thinkingTokens = 0;
+    if (inputTokens + outputTokens + cacheReadTokens === 0) continue;
+    const model = typeof message.modelId === "string" && message.modelId.trim() ? message.modelId.trim() : "unknown";
+    const provider = typeof message.providerId === "string" && message.providerId.trim() ? message.providerId.trim() : inferProvider(model);
+    const ts3 = parseTimestamp(message.timestamp, now);
+    const sessionId = typeof message.conversationId === "string" && message.conversationId.trim() ? message.conversationId.trim() : "unknown";
+    const messageId = typeof message.id === "string" && message.id.trim() ? message.id.trim() : `${sessionId}:${ts3}:${index}`;
+    const sourceKey = `kelivo:${sessionId}:${messageId}`;
+    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, thinkingTokens };
+    const cost = model !== "unknown" ? calculateCost(model, tokenArgs, exchangeRate) : 0;
+    records.push({
+      id: generateRecordId(deviceInstanceId, sourceKey, ts3),
+      ts: ts3,
+      ingestedAt: now,
+      updatedAt: now,
+      lineOffset: index,
+      tool: "kelivo",
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens,
+      cost,
+      costSource: cost > 0 ? "pricing" : "unknown",
+      sessionId,
+      sourceFile: filePath,
+      device,
+      deviceInstanceId,
+      platform: platform5
+    });
+  }
+  return { records, errors };
+}
+
+// src/db/records.ts
+function insertRecord(db, record) {
+  db.prepare(`
+    INSERT OR REPLACE INTO records (
+      id, ts, ingested_at, synced_at, updated_at, line_offset,
+      tool, model, provider, input_tokens, output_tokens,
+      cache_read_tokens, cache_write_tokens, thinking_tokens,
+      cost, cost_source, session_id, source_file, cwd, device, device_instance_id, platform
+    ) VALUES (
+      @id, @ts, @ingestedAt, @syncedAt, @updatedAt, @lineOffset,
+      @tool, @model, @provider, @inputTokens, @outputTokens,
+      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
+      @cost, @costSource, @sessionId, @sourceFile, @cwd, @device, @deviceInstanceId, @platform
+    )
+  `).run({
+    id: record.id,
+    ts: record.ts,
+    ingestedAt: record.ingestedAt,
+    syncedAt: record.syncedAt ?? null,
+    updatedAt: record.updatedAt,
+    lineOffset: record.lineOffset,
+    tool: record.tool,
+    model: record.model,
+    provider: record.provider,
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheReadTokens: record.cacheReadTokens,
+    cacheWriteTokens: record.cacheWriteTokens,
+    thinkingTokens: record.thinkingTokens,
+    cost: record.cost,
+    costSource: record.costSource,
+    sessionId: record.sessionId,
+    sourceFile: record.sourceFile,
+    cwd: record.cwd ?? "",
+    device: record.device,
+    deviceInstanceId: record.deviceInstanceId,
+    platform: record.platform ?? ""
+  });
+}
+function getUnsyncedRecords(db, target) {
+  const rows = target ? db.prepare(`
+        SELECT r.* FROM records r
+        LEFT JOIN sync_record_state s
+          ON s.record_id = r.id AND s.target = ?
+        WHERE r.source_file NOT LIKE 'synced/%'
+          AND (s.synced_at IS NULL OR r.updated_at > s.synced_at)
+      `).all(target) : db.prepare(
+    "SELECT * FROM records WHERE synced_at IS NULL OR updated_at > synced_at"
+  ).all();
+  return rows.map(mapRowToRecord);
+}
+function markRecordsSynced(db, ids, syncedAt, target) {
+  if (ids.length === 0) return;
+  if (target) {
+    const insertStmt = db.prepare(`
+      INSERT INTO sync_record_state (record_id, target, synced_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(record_id, target) DO UPDATE SET synced_at = excluded.synced_at
+    `);
+    const legacyStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
+    const tx2 = db.transaction((recordIds) => {
+      for (const id of recordIds) {
+        insertStmt.run(id, target, syncedAt);
+        legacyStmt.run(syncedAt, id);
+      }
+    });
+    tx2(ids);
+    return;
+  }
+  const updateStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
+  const tx = db.transaction((recordIds) => {
+    for (const id of recordIds) updateStmt.run(syncedAt, id);
+  });
+  tx(ids);
+}
+function mapRowToRecord(row) {
+  return {
+    id: row.id,
+    ts: row.ts,
+    ingestedAt: row.ingested_at,
+    syncedAt: row.synced_at != null ? row.synced_at : void 0,
+    updatedAt: row.updated_at,
+    lineOffset: row.line_offset,
+    tool: row.tool,
+    model: row.model,
+    provider: row.provider,
+    inputTokens: row.input_tokens,
+    outputTokens: row.output_tokens,
+    cacheReadTokens: row.cache_read_tokens,
+    cacheWriteTokens: row.cache_write_tokens,
+    thinkingTokens: row.thinking_tokens,
+    cost: row.cost,
+    costSource: row.cost_source,
+    sessionId: row.session_id,
+    sourceFile: row.source_file,
+    cwd: row.cwd || void 0,
+    device: row.device,
+    deviceInstanceId: row.device_instance_id,
+    platform: row.platform || void 0
+  };
+}
+
 // src/api/server.ts
 var pendingLeaderboardAuth = /* @__PURE__ */ new Map();
+function getManualImportMetadata(db) {
+  const rows = db.prepare(`
+    SELECT tool, MAX(ingested_at) AS lastImportedAt
+    FROM records
+    WHERE tool IN ('kelivo')
+    GROUP BY tool
+  `).all();
+  const metadata = {};
+  for (const row of rows) {
+    if (typeof row.lastImportedAt === "number") {
+      metadata[row.tool] = { lastImportedAt: row.lastImportedAt };
+    }
+  }
+  return metadata;
+}
+function attachManualImportMetadata(tools, db) {
+  const metadata = getManualImportMetadata(db);
+  return tools.map((tool) => {
+    const toolMetadata = metadata[tool.tool];
+    return toolMetadata ? { ...tool, ...toolMetadata } : tool;
+  });
+}
+function countExistingRecordIds(db, ids) {
+  const uniqueIds = [...new Set(ids)];
+  if (uniqueIds.length === 0) return 0;
+  const stmt = db.prepare("SELECT 1 FROM records WHERE id = ? LIMIT 1");
+  let count = 0;
+  for (const id of uniqueIds) {
+    if (stmt.get(id)) count++;
+  }
+  return count;
+}
 function recalcCosts(db) {
   const BATCH_SIZE2 = 1e3;
   let updated = 0;
@@ -3723,6 +4022,44 @@ async function readJsonBody(req) {
   if (!body.trim()) return {};
   return JSON.parse(body);
 }
+async function readBodyBuffer(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  return Buffer.concat(chunks);
+}
+function multipartBoundary(contentType) {
+  const value = Array.isArray(contentType) ? contentType[0] : contentType;
+  if (!value) return null;
+  const match = value.match(/(?:^|;)\s*boundary=("([^"]+)"|[^;]+)/i);
+  if (!match) return null;
+  return (match[2] ?? match[1]).replace(/^"|"$/g, "");
+}
+async function readMultipartFile(req) {
+  const boundary = multipartBoundary(req.headers["content-type"]);
+  if (!boundary) return null;
+  const body = await readBodyBuffer(req);
+  const marker = Buffer.from(`--${boundary}`);
+  let position = body.indexOf(marker);
+  while (position !== -1) {
+    position += marker.length;
+    if (body.subarray(position, position + 2).toString() === "--") return null;
+    if (body.subarray(position, position + 2).toString() === "\r\n") position += 2;
+    const headerEnd = body.indexOf(Buffer.from("\r\n\r\n"), position);
+    if (headerEnd === -1) return null;
+    const headers = body.subarray(position, headerEnd).toString("utf-8");
+    const filenameMatch = headers.match(/Content-Disposition:[^\r\n]*\bname="file"[^\r\n]*\bfilename="([^"]+)"/i);
+    const dataStart = headerEnd + 4;
+    const nextBoundary = body.indexOf(Buffer.from(`\r
+--${boundary}`), dataStart);
+    if (nextBoundary === -1) return null;
+    if (filenameMatch) return { filename: path2.basename(filenameMatch[1]), data: body.subarray(dataStart, nextBoundary) };
+    position = body.indexOf(marker, nextBoundary);
+  }
+  return null;
+}
+function isKelivoBackupFilename(filename) {
+  return filename === "chats.json" || filename.toLowerCase().endsWith(".zip");
+}
 function getDeviceName() {
   return loadConfig()?.device || hostname() || `${platform3()}-${process.arch}`;
 }
@@ -4954,10 +5291,54 @@ function createApiServer(db, options) {
         }
       }
       if (url.pathname === "/api/detected-tools" && req.method === "GET") {
-        const tools = discoverTools();
+        const tools = attachManualImportMetadata(discoverTools(), db);
         json(res, { tools });
         return;
       }
+      if (url.pathname === "/api/import/kelivo" && req.method === "POST") {
+        let tempDir = null;
+        try {
+          const upload = await readMultipartFile(req);
+          if (!upload) {
+            json(res, { error: { code: "INVALID_UPLOAD", message: "Missing uploaded file" } }, 400);
+            return;
+          }
+          if (!isKelivoBackupFilename(upload.filename)) {
+            json(res, { error: { code: "INVALID_FILE", message: "Upload a Kelivo .zip backup or chats.json" } }, 400);
+            return;
+          }
+          tempDir = mkdtempSync(path2.join(tmpdir(), "aiusage-kelivo-"));
+          const tempPath = path2.join(tempDir, upload.filename);
+          writeFileSync4(tempPath, upload.data);
+          const cfg2 = loadConfig();
+          const now = Date.now();
+          const result = await runParseKelivo({
+            filePath: tempPath,
+            device: getDeviceName(),
+            deviceInstanceId: options?.currentDeviceInstanceId ?? "unknown",
+            platform: cfg2?.platform ?? platform3(),
+            now,
+            exchangeRate: resolveExchangeRate(cfg2 ?? {})
+          });
+          if (result.errors.length > 0 && result.records.length === 0) {
+            json(res, { error: { code: "IMPORT_FAILED", message: result.errors[0] }, errors: result.errors }, 400);
+            return;
+          }
+          const existingCount = countExistingRecordIds(db, result.records.map((record) => record.id));
+          for (const record of result.records) insertRecord(db, record);
+          const imported = result.records.length;
+          const added = Math.max(0, new Set(result.records.map((record) => record.id)).size - existingCount);
+          json(res, {
+            imported,
+            added,
+            lastImportedAt: imported > 0 ? now : void 0,
+            errors: result.errors
+          });
+        } finally {
+          if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+        }
+        return;
+      }
       if (url.pathname === "/api/exchange-rate/refresh" && req.method === "POST") {
         const rate = await fetchExchangeRate();
         if (rate == null) {
@@ -4981,114 +5362,12 @@ function createApiServer(db, options) {
 
 // src/commands/parse.ts
 import Database2 from "better-sqlite3";
-import { readFileSync as readFileSync7, statSync as statSync2, existsSync as existsSync8, openSync, readSync, closeSync } from "fs";
+import { readFileSync as readFileSync8, statSync as statSync2, existsSync as existsSync8, openSync, readSync, closeSync } from "fs";
 import { join as join7 } from "path";
 import { hostname as hostname2 } from "os";
 
-// src/db/records.ts
-function insertRecord(db, record) {
-  db.prepare(`
-    INSERT OR REPLACE INTO records (
-      id, ts, ingested_at, synced_at, updated_at, line_offset,
-      tool, model, provider, input_tokens, output_tokens,
-      cache_read_tokens, cache_write_tokens, thinking_tokens,
-      cost, cost_source, session_id, source_file, cwd, device, device_instance_id, platform
-    ) VALUES (
-      @id, @ts, @ingestedAt, @syncedAt, @updatedAt, @lineOffset,
-      @tool, @model, @provider, @inputTokens, @outputTokens,
-      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
-      @cost, @costSource, @sessionId, @sourceFile, @cwd, @device, @deviceInstanceId, @platform
-    )
-  `).run({
-    id: record.id,
-    ts: record.ts,
-    ingestedAt: record.ingestedAt,
-    syncedAt: record.syncedAt ?? null,
-    updatedAt: record.updatedAt,
-    lineOffset: record.lineOffset,
-    tool: record.tool,
-    model: record.model,
-    provider: record.provider,
-    inputTokens: record.inputTokens,
-    outputTokens: record.outputTokens,
-    cacheReadTokens: record.cacheReadTokens,
-    cacheWriteTokens: record.cacheWriteTokens,
-    thinkingTokens: record.thinkingTokens,
-    cost: record.cost,
-    costSource: record.costSource,
-    sessionId: record.sessionId,
-    sourceFile: record.sourceFile,
-    cwd: record.cwd ?? "",
-    device: record.device,
-    deviceInstanceId: record.deviceInstanceId,
-    platform: record.platform ?? ""
-  });
-}
-function getUnsyncedRecords(db, target) {
-  const rows = target ? db.prepare(`
-        SELECT r.* FROM records r
-        LEFT JOIN sync_record_state s
-          ON s.record_id = r.id AND s.target = ?
-        WHERE r.source_file NOT LIKE 'synced/%'
-          AND (s.synced_at IS NULL OR r.updated_at > s.synced_at)
-      `).all(target) : db.prepare(
-    "SELECT * FROM records WHERE synced_at IS NULL OR updated_at > synced_at"
-  ).all();
-  return rows.map(mapRowToRecord);
-}
-function markRecordsSynced(db, ids, syncedAt, target) {
-  if (ids.length === 0) return;
-  if (target) {
-    const insertStmt = db.prepare(`
-      INSERT INTO sync_record_state (record_id, target, synced_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(record_id, target) DO UPDATE SET synced_at = excluded.synced_at
-    `);
-    const legacyStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
-    const tx2 = db.transaction((recordIds) => {
-      for (const id of recordIds) {
-        insertStmt.run(id, target, syncedAt);
-        legacyStmt.run(syncedAt, id);
-      }
-    });
-    tx2(ids);
-    return;
-  }
-  const updateStmt = db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
-  const tx = db.transaction((recordIds) => {
-    for (const id of recordIds) updateStmt.run(syncedAt, id);
-  });
-  tx(ids);
-}
-function mapRowToRecord(row) {
-  return {
-    id: row.id,
-    ts: row.ts,
-    ingestedAt: row.ingested_at,
-    syncedAt: row.synced_at != null ? row.synced_at : void 0,
-    updatedAt: row.updated_at,
-    lineOffset: row.line_offset,
-    tool: row.tool,
-    model: row.model,
-    provider: row.provider,
-    inputTokens: row.input_tokens,
-    outputTokens: row.output_tokens,
-    cacheReadTokens: row.cache_read_tokens,
-    cacheWriteTokens: row.cache_write_tokens,
-    thinkingTokens: row.thinking_tokens,
-    cost: row.cost,
-    costSource: row.cost_source,
-    sessionId: row.session_id,
-    sourceFile: row.source_file,
-    cwd: row.cwd || void 0,
-    device: row.device,
-    deviceInstanceId: row.device_instance_id,
-    platform: row.platform || void 0
-  };
-}
-
 // src/watermark.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
 function defaultFileData() {
   return {
     "claude-code": {},
@@ -5099,6 +5378,7 @@ function defaultFileData() {
     "qoder": {},
     "cursor": {},
     "kilocode": {},
+    "kelivo": {},
     "copilot": {},
     "gemini": {},
     "kimi": {},
@@ -5118,8 +5398,8 @@ function defaultFileData() {
 var WatermarkManager = class {
   data;
   path;
-  constructor(path2) {
-    this.path = path2;
+  constructor(path3) {
+    this.path = path3;
     this.data = this.load();
   }
   load() {
@@ -5127,7 +5407,7 @@ var WatermarkManager = class {
       return { files: defaultFileData() };
     }
     try {
-      const content = readFileSync6(this.path, "utf-8");
+      const content = readFileSync7(this.path, "utf-8");
       const parsed = JSON.parse(content);
       if (parsed && typeof parsed === "object" && !("files" in parsed)) {
         return { files: { ...defaultFileData(), ...parsed } };
@@ -5138,7 +5418,7 @@ var WatermarkManager = class {
     }
   }
   save() {
-    writeFileSync4(this.path, JSON.stringify(this.data, null, 2), "utf-8");
+    writeFileSync5(this.path, JSON.stringify(this.data, null, 2), "utf-8");
   }
   getEntry(tool, filePath) {
     return this.data.files[tool]?.[filePath] ?? null;
@@ -6023,12 +6303,12 @@ function parseUiMessagesFile(options) {
   const errors = [];
   let messages;
   try {
-    const parsed = JSON.parse(readFileSync7(filePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(filePath, "utf-8"));
     messages = Array.isArray(parsed) ? parsed : [];
   } catch (e) {
     return { records, errors: [`${filePath}: ${e instanceof Error ? e.message : e}`] };
   }
-  const taskId = filePath.split("/").slice(-2, -1)[0] || "unknown";
+  const taskId = filePath.replace(/\\/g, "/").split("/").slice(-2, -1)[0] || "unknown";
   for (const [index, message] of messages.entries()) {
     if (message?.say !== "api_req_started" || typeof message.text !== "string") continue;
     let payload;
@@ -6080,7 +6360,7 @@ function normalizeKiroModel(value) {
   if (typeof value !== "string" || !value.trim()) return "kiro-agent";
   return value.trim().toLowerCase().replace(/_/g, "-").replace(/^(anthropic\.|openai\.|aws\.)/, "").replace(/:\d+$/, "").replace(/-\d{8}-v\d+(?:-\d+)?$/i, "");
 }
-function parseTimestamp(value, fallback) {
+function parseTimestamp2(value, fallback) {
   if (typeof value === "number" && Number.isFinite(value)) return value < 1e12 ? value * 1e3 : value;
   if (typeof value === "string" && value.trim()) {
     const parsed = new Date(value).getTime();
@@ -6101,7 +6381,7 @@ function parseKiroSessionFile(options) {
   const errors = [];
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync7(filePath, "utf-8"));
+    parsed = JSON.parse(readFileSync8(filePath, "utf-8"));
   } catch (e) {
     return { records, errors: [`${filePath}: ${e instanceof Error ? e.message : e}`] };
   }
@@ -6114,7 +6394,7 @@ function parseKiroSessionFile(options) {
     const outputTokens = toNumber2(turn?.output_token_count);
     if (inputTokens + outputTokens === 0) continue;
     const model = normalizeKiroModel(turn?.model_id ?? sessionModel);
-    const recordTs = parseTimestamp(
+    const recordTs = parseTimestamp2(
       turn?.request_start_timestamp_ms ?? turn?.start_timestamp ?? turn?.end_timestamp,
       now
     );
@@ -6225,7 +6505,30 @@ async function runParse(db, filterTool, options) {
           onProgress({ phase: "Parsing logs", tool, current: fileIndex, total: totalFiles, records: parsedCount, toolCalls: toolCallCount });
           continue;
         }
-        const content = readFileSync7(filePath, "utf-8");
+        if (tool === "kelivo" && (filePath.endsWith("chats.json") || filePath.endsWith(".zip"))) {
+          const result = await runParseKelivo({
+            filePath,
+            device,
+            deviceInstanceId,
+            platform: devicePlatform,
+            now: Date.now(),
+            exchangeRate
+          });
+          for (const record of result.records) {
+            insertRecord(db, record);
+            parsedCount++;
+          }
+          errors.push(...result.errors);
+          wm.setEntry(tool, filePath, {
+            offset: stat2.size,
+            size: stat2.size,
+            mtime: stat2.mtimeMs
+          });
+          wm.save();
+          onProgress({ phase: "Parsing logs", tool, current: fileIndex, total: totalFiles, records: parsedCount, toolCalls: toolCallCount });
+          continue;
+        }
+        const content = readFileSync8(filePath, "utf-8");
         const lines = content.split("\n");
         let byteOffset = 0;
         let fileCwd;
@@ -6680,7 +6983,7 @@ function backfillCodexModels(db) {
   );
   for (const [sourceFile, fileRows] of byFile) {
     try {
-      const content = readFileSync7(sourceFile, "utf-8");
+      const content = readFileSync8(sourceFile, "utf-8");
       const lines = content.split("\n");
       const offsetToModel = /* @__PURE__ */ new Map();
       let currentModel = "";
@@ -6728,7 +7031,7 @@ function backfillMissingToolCalls(db, exchangeRate) {
   }
   for (const [sourceFile, fileRows] of rowsByFile) {
     try {
-      const content = readFileSync7(sourceFile, "utf-8");
+      const content = readFileSync8(sourceFile, "utf-8");
       const lines = content.split("\n");
       const aggregator = new Aggregator();
       const recordIdByOffset = /* @__PURE__ */ new Map();
@@ -6907,6 +7210,7 @@ var RECORD_ID_SYNC_TOOLS = /* @__PURE__ */ new Set([
   "qoder",
   "cursor",
   "kilocode",
+  "kelivo",
   "goose",
   "zed",
   "kiro",
@@ -7015,15 +7319,15 @@ var SyncOrchestrator = class {
     });
     if (paths.length === 0) return 0;
     let totalPulled = 0;
-    for (const [index, path2] of paths.entries()) {
+    for (const [index, path3] of paths.entries()) {
       this.options.onProgress?.({
         phase: "pulling",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index,
         totalFiles: paths.length,
         pulledCount: totalPulled
       });
-      const content = await this.backend.readFile(path2);
+      const content = await this.backend.readFile(path3);
       if (!content) continue;
       for (const line of content.split("\n").filter(Boolean)) {
         try {
@@ -7041,7 +7345,7 @@ var SyncOrchestrator = class {
       }
       this.options.onProgress?.({
         phase: "pulling",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index + 1,
         totalFiles: paths.length,
         pulledCount: totalPulled
@@ -7049,13 +7353,13 @@ var SyncOrchestrator = class {
     }
     return totalPulled;
   }
-  async uploadFile(path2, localSyncRecords) {
-    const existingContent = await this.backend.readFile(path2);
+  async uploadFile(path3, localSyncRecords) {
+    const existingContent = await this.backend.readFile(path3);
     const existing = existingContent ? parseNdjson(existingContent) : /* @__PURE__ */ new Map();
     const changedCount = mergeRecords(existing, localSyncRecords);
     if (changedCount === 0) return 0;
     const content = Array.from(existing.values()).map((r) => JSON.stringify(r)).join("\n") + "\n";
-    await this.backend.writeFile(path2, content);
+    await this.backend.writeFile(path3, content);
     return changedCount;
   }
   async upload() {
@@ -7063,9 +7367,9 @@ var SyncOrchestrator = class {
     if (unsynced.length === 0) return 0;
     const byPath = /* @__PURE__ */ new Map();
     for (const record of unsynced) {
-      const path2 = getSyncPath(record.ts, this.options.deviceInstanceId);
-      if (!byPath.has(path2)) byPath.set(path2, []);
-      byPath.get(path2).push(record);
+      const path3 = getSyncPath(record.ts, this.options.deviceInstanceId);
+      if (!byPath.has(path3)) byPath.set(path3, []);
+      byPath.get(path3).push(record);
     }
     let totalUploaded = 0;
     const uploads = Array.from(byPath.entries());
@@ -7075,20 +7379,20 @@ var SyncOrchestrator = class {
       totalFiles: uploads.length,
       uploadedCount: 0
     });
-    for (const [index, [path2, localRecords]] of uploads.entries()) {
+    for (const [index, [path3, localRecords]] of uploads.entries()) {
       this.options.onProgress?.({
         phase: "uploading",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index,
         totalFiles: uploads.length,
         uploadedCount: totalUploaded
       });
       const localSyncRecords = localRecords.map(mapStatsRecordToSyncRecord);
-      await this.uploadFile(path2, localSyncRecords);
+      await this.uploadFile(path3, localSyncRecords);
       totalUploaded += localRecords.length;
       this.options.onProgress?.({
         phase: "uploading",
-        currentPath: path2,
+        currentPath: path3,
         completedFiles: index + 1,
         totalFiles: uploads.length,
         uploadedCount: totalUploaded
@@ -7113,14 +7417,14 @@ var CloudSyncError = class extends Error {
   code;
   retryAfter;
 };
-function buildHeaders(method, path2, body) {
+function buildHeaders(method, path3, body) {
   const creds = loadCredentials();
   if (!creds) throw new CloudSyncError("Not logged in. Run `aiusage login` first.", "not_logged_in");
   const bodyHash = sha256(body);
   const timestamp = Date.now().toString();
   const nonce = generateNonce();
   const idempotencyKey = generateIdempotencyKey();
-  const canonical = buildCanonicalString(method, path2, bodyHash, timestamp, nonce, creds.device_id, idempotencyKey);
+  const canonical = buildCanonicalString(method, path3, bodyHash, timestamp, nonce, creds.device_id, idempotencyKey);
   const signature = computeHmac(creds.device_secret, canonical);
   return {
     "Content-Type": "application/json",
@@ -7179,9 +7483,9 @@ async function cloudPull(cursor, limit = 1e3) {
   if (cursor) params.set("cursor", cursor);
   params.set("limit", String(limit));
   const query = params.toString();
-  const path2 = `${SYNC_PULL_PATH}${query ? `?${query}` : ""}`;
+  const path3 = `${SYNC_PULL_PATH}${query ? `?${query}` : ""}`;
   const headers = buildHeaders("GET", SYNC_PULL_PATH, "");
-  const response = await fetch(`${serverUrl}${path2}`, { method: "GET", headers });
+  const response = await fetch(`${serverUrl}${path3}`, { method: "GET", headers });
   const data = await readJsonOrNull2(response);
   if (!response.ok) {
     const errObj = data?.error;
@@ -7198,12 +7502,32 @@ async function cloudPull(cursor, limit = 1e3) {
     syncGeneration: data.sync_generation || 1
   };
 }
+async function cloudClear() {
+  const serverUrl = getSiteUrl();
+  const creds = loadCredentials();
+  if (!creds) throw new CloudSyncError("Not logged in.", "not_logged_in");
+  const SYNC_CLEAR_PATH = "/api/cli/sync/clear";
+  const body = "{}";
+  const headers = buildHeaders("POST", SYNC_CLEAR_PATH, body);
+  const response = await fetch(`${serverUrl}${SYNC_CLEAR_PATH}`, { method: "POST", headers, body });
+  const data = await readJsonOrNull2(response);
+  if (!response.ok) {
+    const errObj = data?.error;
+    const errMsg = typeof errObj === "object" && errObj !== null ? errObj.message || `Clear failed (HTTP ${response.status})` : errObj || `Clear failed (HTTP ${response.status})`;
+    const errCode = typeof errObj === "object" && errObj !== null ? errObj.code || "server_error" : data?.error_code || "server_error";
+    throw new CloudSyncError(errMsg, errCode);
+  }
+  if (!data) throw new CloudSyncError("Invalid response from server", "invalid_response");
+  return {
+    syncGeneration: data.sync_generation || 1
+  };
+}
 function getClientVersion() {
   try {
-    const { readFileSync: readFileSync11 } = __require("fs");
+    const { readFileSync: readFileSync12 } = __require("fs");
     const { join: join16 } = __require("path");
     const pkgPath = join16(__dirname, "../../package.json");
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -7293,7 +7617,7 @@ var CloudSyncOrchestrator = class {
 // src/sync/git.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { readFile, writeFile, mkdir, readdir, stat } from "fs/promises";
+import { readFile, writeFile, mkdir, readdir, stat, unlink, rm } from "fs/promises";
 import { join as join8 } from "path";
 var exec = promisify(execFile);
 var GitSyncBackend = class _GitSyncBackend {
@@ -7353,16 +7677,16 @@ var GitSyncBackend = class _GitSyncBackend {
       }
     }
   }
-  async readFile(path2) {
+  async readFile(path3) {
     try {
-      const fullPath = join8(this.dataDir, path2);
+      const fullPath = join8(this.dataDir, path3);
       return await readFile(fullPath, "utf-8");
     } catch {
       return null;
     }
   }
-  async writeFile(path2, content) {
-    const fullPath = join8(this.dataDir, path2);
+  async writeFile(path3, content) {
+    const fullPath = join8(this.dataDir, path3);
     await mkdir(join8(fullPath, ".."), { recursive: true });
     await writeFile(fullPath, content, "utf-8");
   }
@@ -7373,6 +7697,22 @@ var GitSyncBackend = class _GitSyncBackend {
       return [];
     }
   }
+  async deleteFile(path3) {
+    const fullPath = join8(this.dataDir, path3);
+    try {
+      await unlink(fullPath);
+    } catch {
+    }
+  }
+  async deleteAllData() {
+    try {
+      const files = await this.listFiles();
+      await rm(this.dataDir, { recursive: true, force: true });
+      return files.length;
+    } catch {
+      return 0;
+    }
+  }
   static MAX_PUSH_RETRIES = 3;
   /** Commit and push all changes. Returns true if anything was pushed. */
   async flush() {
@@ -7407,7 +7747,7 @@ var GitSyncBackend = class _GitSyncBackend {
 };
 
 // src/sync/s3.ts
-import { S3Client, GetObjectCommand, PutObjectCommand, HeadObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";
+import { S3Client, GetObjectCommand, PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, DeleteObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 var S3SyncBackend = class {
   client;
   bucket;
@@ -7424,11 +7764,11 @@ var S3SyncBackend = class {
       }
     });
   }
-  getObjectKey(path2) {
-    return `${this.prefix}${path2}`;
+  getObjectKey(path3) {
+    return `${this.prefix}${path3}`;
   }
-  async readFile(path2) {
-    const key = this.getObjectKey(path2);
+  async readFile(path3) {
+    const key = this.getObjectKey(path3);
     try {
       const command = new GetObjectCommand({
         Bucket: this.bucket,
@@ -7444,8 +7784,8 @@ var S3SyncBackend = class {
       throw error;
     }
   }
-  async writeFile(path2, content) {
-    const key = this.getObjectKey(path2);
+  async writeFile(path3, content) {
+    const key = this.getObjectKey(path3);
     const command = new PutObjectCommand({
       Bucket: this.bucket,
       Key: key,
@@ -7477,8 +7817,8 @@ var S3SyncBackend = class {
     } while (continuationToken);
     return files.sort();
   }
-  async fileExists(path2) {
-    const key = this.getObjectKey(path2);
+  async fileExists(path3) {
+    const key = this.getObjectKey(path3);
     try {
       const command = new HeadObjectCommand({
         Bucket: this.bucket,
@@ -7493,6 +7833,31 @@ var S3SyncBackend = class {
       throw error;
     }
   }
+  async deleteFile(path3) {
+    const key = this.getObjectKey(path3);
+    const command = new DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    });
+    await this.client.send(command);
+  }
+  async deleteAllData() {
+    const files = await this.listFiles();
+    if (files.length === 0) return 0;
+    const BATCH_SIZE2 = 1e3;
+    for (let i = 0; i < files.length; i += BATCH_SIZE2) {
+      const batch = files.slice(i, i + BATCH_SIZE2);
+      const command = new DeleteObjectsCommand({
+        Bucket: this.bucket,
+        Delete: {
+          Objects: batch.map((f) => ({ Key: this.getObjectKey(f) })),
+          Quiet: true
+        }
+      });
+      await this.client.send(command);
+    }
+    return files.length;
+  }
 };
 
 // src/commands/sync.ts
@@ -7601,6 +7966,8 @@ async function runSync(db, options) {
 }
 
 // src/commands/clean.ts
+import { unlinkSync as unlinkSync2, existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
 function cleanOldData(db, days) {
   const cutoff = Date.now() - days * 864e5;
   const recordsResult = db.prepare("DELETE FROM records WHERE ts < ?").run(cutoff);
@@ -7615,6 +7982,172 @@ function cleanOldData(db, days) {
     deletedOrphanToolCalls
   };
 }
+function cleanAll(db) {
+  const recordsResult = db.prepare("DELETE FROM records").run();
+  const toolCallsResult = db.prepare("DELETE FROM tool_calls").run();
+  const syncedResult = db.prepare("DELETE FROM synced_records").run();
+  const syncStateResult = db.prepare("DELETE FROM sync_record_state").run();
+  const tombstonesResult = db.prepare("DELETE FROM sync_tombstones").run();
+  const watermarkPath = join10(AIUSAGE_DIR, "watermark.json");
+  let watermarkRemoved = false;
+  if (existsSync9(watermarkPath)) {
+    unlinkSync2(watermarkPath);
+    watermarkRemoved = true;
+  }
+  return {
+    deletedRecords: recordsResult.changes,
+    deletedToolCalls: toolCallsResult.changes,
+    deletedSyncedRecords: syncedResult.changes,
+    deletedSyncRecordState: syncStateResult.changes,
+    deletedTombstones: tombstonesResult.changes,
+    watermarkRemoved
+  };
+}
+function getRemoteBackends() {
+  const config = loadConfig();
+  if (!config?.sync) return [];
+  const backends = [];
+  if (config.sync.backend === "cloud") {
+    backends.push({ type: "cloud", label: "AIUsage Cloud (cloud)" });
+  } else if (config.sync.backend === "github" && config.sync.repo) {
+    backends.push({ type: "github", label: `GitHub (${config.sync.repo})` });
+  } else if (config.sync.backend === "s3" && config.sync.bucket) {
+    backends.push({ type: "s3", label: `S3 (${config.sync.bucket})` });
+  }
+  return backends;
+}
+function createBackend2(config) {
+  if (!config?.sync) return null;
+  if (config.sync.backend === "github") {
+    if (!config.sync.repo) return null;
+    const token = loadCredential(`github/${config.sync.repo}/token`);
+    if (!token) return null;
+    return new GitSyncBackend({
+      repo: config.sync.repo,
+      token,
+      cacheDir: join10(AIUSAGE_DIR, "sync-repo")
+    });
+  }
+  if (config.sync.backend === "s3") {
+    if (!config.sync.bucket) return null;
+    const accessKeyId = loadCredential(`s3/${config.sync.bucket}/accessKeyId`);
+    const secretAccessKey = loadCredential(`s3/${config.sync.bucket}/secretAccessKey`);
+    if (!accessKeyId || !secretAccessKey) return null;
+    return new S3SyncBackend({
+      bucket: config.sync.bucket,
+      prefix: config.sync.prefix ?? "aiusage/",
+      accessKeyId,
+      secretAccessKey,
+      endpoint: config.sync.endpoint,
+      region: config.sync.region
+    });
+  }
+  return null;
+}
+async function propagateClean(options) {
+  const config = loadConfig();
+  if (!config?.sync) return { backends: [] };
+  const results = [];
+  if (config.sync.backend === "cloud") {
+    if (!options.target || options.target === "cloud") {
+      try {
+        const result = await cloudClear();
+        results.push({
+          backend: { type: "cloud", label: "AIUsage Cloud" },
+          status: "ok",
+          detail: `generation updated to ${result.syncGeneration}`
+        });
+      } catch (err) {
+        results.push({
+          backend: { type: "cloud", label: "AIUsage Cloud" },
+          status: "skipped",
+          detail: err instanceof Error ? err.message : "unknown error"
+        });
+      }
+    }
+    return { backends: results };
+  }
+  if (options.target && options.target !== config.sync.backend) {
+    return { backends: results };
+  }
+  const backend = createBackend2(config);
+  if (!backend) {
+    return { backends: [{
+      backend: { type: config.sync.backend, label: config.sync.backend },
+      status: "skipped",
+      detail: "Could not create backend (missing credentials)"
+    }] };
+  }
+  try {
+    await backend.prepare?.();
+    if (options.all) {
+      const files = await backend.listFiles();
+      const fileCount = files.length;
+      if (fileCount > 0) {
+        await backend.deleteAllData();
+      }
+      await backend.flush?.();
+      results.push({
+        backend: {
+          type: config.sync.backend,
+          label: config.sync.backend === "github" ? `GitHub (${config.sync.repo})` : `S3 (${config.sync.bucket})`
+        },
+        status: "ok",
+        detail: `cleared ${fileCount} files`
+      });
+    } else if (options.beforeDays) {
+      const cutoff = Date.now() - options.beforeDays * 864e5;
+      const files = await backend.listFiles();
+      let removedRecords = 0;
+      let modifiedFiles = 0;
+      for (const file of files) {
+        const content = await backend.readFile(file);
+        if (!content) continue;
+        const lines = content.split("\n").filter(Boolean);
+        const kept = [];
+        for (const line of lines) {
+          try {
+            const record = JSON.parse(line);
+            const ts3 = typeof record.ts === "string" ? new Date(record.ts).getTime() : record.ts;
+            if (ts3 >= cutoff) {
+              kept.push(line);
+            } else {
+              removedRecords++;
+            }
+          } catch {
+            kept.push(line);
+          }
+        }
+        if (kept.length === 0) {
+          await backend.deleteFile?.(file);
+          modifiedFiles++;
+        } else if (kept.length < lines.length) {
+          await backend.writeFile(file, kept.join("\n") + "\n");
+          modifiedFiles++;
+        }
+      }
+      await backend.flush?.();
+      results.push({
+        backend: {
+          type: config.sync.backend,
+          label: config.sync.backend === "github" ? `GitHub (${config.sync.repo})` : `S3 (${config.sync.bucket})`
+        },
+        status: "ok",
+        detail: `removed ${removedRecords} records from ${modifiedFiles} files`
+      });
+    }
+  } catch (err) {
+    results.push({
+      backend: {
+        type: config.sync.backend,
+        label: config.sync.backend === "github" ? `GitHub (${config.sync.repo})` : `S3 (${config.sync.bucket})`
+      },
+      status: "skipped",
+      detail: err instanceof Error ? err.message : "unknown error"
+    });
+  }
+  return { backends: results };
+}
 
 // src/sync/runtime.ts
 var SyncRuntimeController = class {
@@ -7817,7 +8350,7 @@ var RuntimeSettingsController = class {
 
 // src/commands/serve.ts
 var MAX_PORT_ATTEMPTS = 10;
-var PORT_FILE = join10(AIUSAGE_DIR, ".serve-port");
+var PORT_FILE = join11(AIUSAGE_DIR, ".serve-port");
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -7879,11 +8412,11 @@ function serve(options) {
     onConfigUpdated: () => runtimeSettings.reload()
   });
   const webBuildDir = (() => {
-    const prodDir = join10(dirname3(fileURLToPath(import.meta.url)), "web");
-    if (existsSync9(prodDir)) return prodDir;
-    return join10(dirname3(fileURLToPath(import.meta.url)), "..", "..", "..", "web", "build");
+    const prodDir = join11(dirname3(fileURLToPath(import.meta.url)), "web");
+    if (existsSync10(prodDir)) return prodDir;
+    return join11(dirname3(fileURLToPath(import.meta.url)), "..", "..", "..", "web", "build");
   })();
-  if (!existsSync9(webBuildDir)) {
+  if (!existsSync10(webBuildDir)) {
     console.error("Web dashboard not found. Reinstall the package: npm install -g @juliantanx/aiusage");
     process.exit(1);
   }
@@ -7893,19 +8426,19 @@ function serve(options) {
       apiServer.emit("request", req, res);
       return;
     }
-    if (existsSync9(webBuildDir)) {
-      let filePath = join10(webBuildDir, url.pathname);
+    if (existsSync10(webBuildDir)) {
+      let filePath = join11(webBuildDir, url.pathname);
       try {
         if (statSync3(filePath).isDirectory()) {
-          filePath = join10(filePath, "index.html");
+          filePath = join11(filePath, "index.html");
         }
       } catch {
       }
-      if (!existsSync9(filePath)) {
-        filePath = join10(webBuildDir, "index.html");
+      if (!existsSync10(filePath)) {
+        filePath = join11(webBuildDir, "index.html");
       }
       try {
-        const content = readFileSync8(filePath);
+        const content = readFileSync9(filePath);
         const ext = extname2(filePath);
         const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
         res.writeHead(200, { "Content-Type": contentType });
@@ -7925,7 +8458,7 @@ function serve(options) {
   };
   server.on("listening", () => {
     started = true;
-    writeFileSync5(PORT_FILE, String(currentPort), "utf-8");
+    writeFileSync6(PORT_FILE, String(currentPort), "utf-8");
     console.log(`aiusage serve listening on http://localhost:${currentPort}`);
   });
   server.on("error", (error) => {
@@ -7943,7 +8476,7 @@ function serve(options) {
   listenOnPort(options.port);
   const cleanup = () => {
     try {
-      unlinkSync2(PORT_FILE);
+      unlinkSync3(PORT_FILE);
     } catch {
     }
   };
@@ -8087,9 +8620,9 @@ Consent recorded for schema v1.`
 }
 
 // src/commands/status.ts
-import { statSync as statSync4, existsSync as existsSync10 } from "fs";
+import { statSync as statSync4, existsSync as existsSync11 } from "fs";
 import { hostname as hostname3 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function formatFileSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -8107,9 +8640,9 @@ function generateStatus(db) {
   const schemaVersion = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get()?.version ?? 0;
   const tableCount = db.prepare("SELECT COUNT(*) as count FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").get()?.count ?? 0;
   const viewCount = db.prepare("SELECT COUNT(*) as count FROM sqlite_master WHERE type = 'view'").get()?.count ?? 0;
-  const sizePath = join11(AIUSAGE_DIR, "cache.db");
+  const sizePath = join12(AIUSAGE_DIR, "cache.db");
   let databaseSize = "0 B";
-  if (existsSync10(sizePath)) {
+  if (existsSync11(sizePath)) {
     try {
       const stat2 = statSync4(sizePath);
       databaseSize = formatFileSize(stat2.size);
@@ -8186,27 +8719,6 @@ function exportData(db, format) {
   return lines.join("\n");
 }
 
-// src/commands/reset.ts
-import { unlinkSync as unlinkSync3, existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
-function runReset(db) {
-  const recordsResult = db.prepare("DELETE FROM records").run();
-  const toolCallsResult = db.prepare("DELETE FROM tool_calls").run();
-  const syncedResult = db.prepare("DELETE FROM synced_records").run();
-  const watermarkPath = join12(AIUSAGE_DIR, "watermark.json");
-  let watermarkRemoved = false;
-  if (existsSync11(watermarkPath)) {
-    unlinkSync3(watermarkPath);
-    watermarkRemoved = true;
-  }
-  return {
-    deletedRecords: recordsResult.changes,
-    deletedToolCalls: toolCallsResult.changes,
-    deletedSyncedRecords: syncedResult.changes,
-    watermarkRemoved
-  };
-}
-
 // src/commands/recalc.ts
 var BATCH_SIZE = 1e3;
 function recalcPricing(db) {
@@ -8319,7 +8831,7 @@ var SyncProgressReporter = class {
 };
 
 // src/commands/widget.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { spawn, execSync as execSync2 } from "child_process";
 import { join as join13 } from "path";
 var WIDGET_PID_PATH = join13(AIUSAGE_DIR, "widget.pid");
@@ -8347,7 +8859,7 @@ function isWidgetRunning() {
   if (!existsSync12(WIDGET_PID_PATH)) return false;
   let pid;
   try {
-    pid = parseInt(readFileSync9(WIDGET_PID_PATH, "utf-8").trim(), 10);
+    pid = parseInt(readFileSync10(WIDGET_PID_PATH, "utf-8").trim(), 10);
   } catch {
     return false;
   }
@@ -8391,10 +8903,10 @@ function getDeviceName2() {
 }
 function getCliVersion2() {
   try {
-    const { readFileSync: readFileSync11 } = __require("fs");
+    const { readFileSync: readFileSync12 } = __require("fs");
     const { join: join16 } = __require("path");
     const pkgPath = join16(__dirname, "../../package.json");
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -8638,7 +9150,7 @@ async function runLeaderboardView(options = {}) {
 // src/commands/menu.ts
 import { createInterface } from "readline";
 import { spawn as spawn2, spawnSync, execSync as execSync4 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
 import { join as join14 } from "path";
 var DEFAULT_PORT = 3847;
 var PORT_FILE2 = join14(AIUSAGE_DIR, ".serve-port");
@@ -8647,7 +9159,7 @@ function clearScreen() {
 }
 function getPort() {
   if (existsSync13(PORT_FILE2)) {
-    const raw = readFileSync10(PORT_FILE2, "utf-8").trim();
+    const raw = readFileSync11(PORT_FILE2, "utf-8").trim();
     const n = parseInt(raw, 10);
     if (!isNaN(n) && n > 0) return n;
   }
@@ -8825,11 +9337,10 @@ async function dataSubmenu(rl) {
   [2] Summary
   [3] Export
   [4] Clean
-  [5] Reset
-  [6] Recalc
+  [5] Recalc
   [0] Back
 `);
-    const choice = await prompt(rl, "  Select [0-6]: ");
+    const choice = await prompt(rl, "  Select [0-5]: ");
     switch (choice) {
       case "1": {
         const progress = await prompt(rl, "  Show progress? [Y/N]: ");
@@ -8865,28 +9376,28 @@ async function dataSubmenu(rl) {
         break;
       }
       case "4": {
-        const dur = await prompt(rl, "  Duration to keep (default 180d): ");
-        const before = dur || "180d";
+        const mode = await prompt(rl, "  1=Old data (180d)  2=Old data (custom)  3=All (=reset): ");
         console.log("");
-        runCommand(["clean", "--before", before, "--yes"]);
-        await prompt(rl, "\n  Press Enter to continue...");
-        break;
-      }
-      case "5": {
-        const confirm = await prompt(
-          rl,
-          '  WARNING: This will delete ALL parsed data. Type "yes" to confirm: '
-        );
-        if (confirm.toLowerCase() === "yes") {
-          console.log("");
-          runCommand(["reset", "--yes"]);
+        if (mode === "3") {
+          const confirm = await prompt(
+            rl,
+            '  WARNING: This will delete ALL parsed data. Type "confirm" to proceed: '
+          );
+          if (confirm.toLowerCase() === "confirm") {
+            runCommand(["clean", "--all", "--yes"]);
+          } else {
+            console.log("  Cancelled.");
+          }
+        } else if (mode === "2") {
+          const dur = await prompt(rl, "  Duration to keep (e.g. 30d, 90d): ");
+          runCommand(["clean", "--before", dur || "180d", "--yes"]);
         } else {
-          console.log("\n  Cancelled.");
+          runCommand(["clean", "--before", "180d", "--yes"]);
         }
         await prompt(rl, "\n  Press Enter to continue...");
         break;
       }
-      case "6": {
+      case "5": {
         console.log("");
         runCommand(["recalc"]);
         await prompt(rl, "\n  Press Enter to continue...");
@@ -9101,7 +9612,7 @@ async function runMenu() {
 ${dashboardStatusLine()}
 
   [1] Dashboard      (serve/stop/restart/open)
-  [2] Data           (parse/summary/export/clean/reset/recalc)
+  [2] Data           (parse/summary/export/clean/recalc)
   [3] Sync           (init/sync)
   [4] Leaderboard    (view/login/upload/status/logout)
   [5] System         (status/widget/pm2/update)
@@ -9140,7 +9651,7 @@ ${dashboardStatusLine()}
 import { join as join15 } from "path";
 var DB_PATH2 = join15(AIUSAGE_DIR, "cache.db");
 var program = new Command();
-program.name("aiusage").version(true ? "1.5.1" : "dev").description("CLI tool for AI usage statistics");
+program.name("aiusage").version(true ? "1.5.2" : "dev").description("CLI tool for AI usage statistics");
 program.action(() => {
   const unknownCommand = program.args.find((arg) => typeof arg === "string");
   if (unknownCommand) {
@@ -9222,7 +9733,7 @@ program.command("export").description("Export data").requiredOption("--format <f
   const db = createDatabase(DB_PATH2);
   const data = exportData(db, format);
   if (options.output) {
-    writeFileSync6(options.output, data, "utf-8");
+    writeFileSync7(options.output, data, "utf-8");
     console.log(`Exported to ${options.output}`);
   } else {
     console.log(data);
@@ -9249,32 +9760,109 @@ program.command("parse").description("Parse AI tool session logs").option("--too
     db.close();
   }
 });
-program.command("clean").description("Clean old data").option("--before <duration>", "Duration (e.g., 30d)", "180d").option("--remote", "Also clean remote data").option("--all-devices", "Clean all devices (with --remote)").option("--yes", "Skip confirmation").option("--approve-delete", "Approve delete permission upgrade").action((options) => {
-  const daysMatch = options.before.match(/^(\d+)d$/);
-  if (!daysMatch) {
-    console.error("Invalid duration format. Use e.g. 30d, 180d.");
+program.command("clean").description("Clean data (old records or all data)").option("--before <duration>", "Delete data older than this (e.g., 30d, 180d)", "180d").option("--all", "Wipe all data (equivalent to former reset: all records, tool calls, watermark)").option("--local-only", "Only clean local data, do not propagate to remote backends").option("--target <backend>", "Target specific remote backend (github/s3/cloud)").option("--yes", "Skip local confirmation (remote deletion still requires confirmation)").action(async (options) => {
+  const isAll = !!options.all;
+  const localOnly = !!options.localOnly;
+  let days = 0;
+  if (isAll && options.before !== "180d") {
+    console.error("Cannot use --all and --before together. Use one or the other.");
     process.exit(1);
   }
-  const days = parseInt(daysMatch[1], 10);
-  const db = createDatabase(DB_PATH2);
-  const result = cleanOldData(db, days);
-  console.log(`Deleted ${result.deletedCount} records, ${result.deletedSyncedCount} synced records, ${result.deletedOrphanToolCalls} orphan tool calls.`);
-  db.close();
-});
-program.command("reset").description("Delete all parsed data and watermark, then re-parse from scratch").option("--yes", "Skip confirmation").action((options) => {
+  if (!isAll) {
+    const daysMatch = options.before.match(/^(\d+)d$/);
+    if (!daysMatch) {
+      console.error("Invalid duration format. Use e.g. 30d, 180d.");
+      process.exit(1);
+    }
+    days = parseInt(daysMatch[1], 10);
+  }
+  const remoteBackends = localOnly ? [] : getRemoteBackends();
+  if (isAll) {
+    console.log("\x1B[33m\u26A0 WARNING: This will delete ALL parsed data, tool calls, synced records,\x1B[0m");
+    console.log("\x1B[33m  and the parse watermark. Next parse will re-import from scratch.\x1B[0m");
+  } else {
+    console.log(`This will delete local records older than ${days} days.`);
+  }
+  if (localOnly) {
+    console.log("\x1B[36m  (--local-only: remote data will NOT be affected)\x1B[0m");
+  }
+  if (remoteBackends.length > 0) {
+    console.log("\nCloud sync is configured. The following remote backends will also be affected:");
+    for (const rb of remoteBackends) {
+      console.log(`  - ${rb.label}`);
+    }
+  }
+  const ask = async (question) => {
+    if (!process.stdin.isTTY) {
+      console.error("Non-interactive mode detected. Use --local-only to skip remote propagation, or run interactively.");
+      process.exit(1);
+    }
+    const { createInterface: createInterface2 } = await import("readline");
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve2) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve2(answer.trim());
+      });
+    });
+  };
   if (!options.yes) {
-    console.error("This will delete ALL parsed records, tool calls, synced data, and the parse watermark.");
-    console.error("Source log files (~/.claude, ~/.codex, etc.) will NOT be affected.");
-    console.error("Use --yes to confirm.");
-    process.exit(1);
+    if (remoteBackends.length > 0) {
+      const answer = await ask(`
+? Confirm deletion on local + ${remoteBackends.length} remote backend(s)? [y/N] `);
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        process.exit(0);
+      }
+    } else {
+      const answer = await ask("\n? Confirm? [y/N] ");
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        process.exit(0);
+      }
+    }
+  } else if (remoteBackends.length > 0) {
+    const answer = await ask('\n? Type "confirm" to proceed with remote deletion: ');
+    if (answer !== "confirm") {
+      console.log("Cancelled.");
+      process.exit(0);
+    }
   }
   const db = createDatabase(DB_PATH2);
-  const result = runReset(db);
-  console.log(`Deleted ${result.deletedRecords} records, ${result.deletedToolCalls} tool calls, ${result.deletedSyncedRecords} synced records.`);
-  if (result.watermarkRemoved) {
-    console.log("Watermark removed \u2014 next parse will re-import all data from scratch.");
+  if (isAll) {
+    console.log("\nDeleting all local data...");
+    const result = cleanAll(db);
+    console.log(`  Local: deleted ${result.deletedRecords} records, ${result.deletedToolCalls} tool calls, ${result.deletedSyncedRecords} synced records`);
+    if (result.watermarkRemoved) {
+      console.log("  Watermark removed");
+    }
+  } else {
+    console.log(`
+Cleaning local records older than ${days} days...`);
+    const result = cleanOldData(db, days);
+    console.log(`  Local: deleted ${result.deletedCount} records, ${result.deletedSyncedCount} synced records, ${result.deletedOrphanToolCalls} orphan tool calls`);
   }
   db.close();
+  if (remoteBackends.length > 0) {
+    console.log("\nSyncing deletion to remote backends...");
+    try {
+      const propagation = await propagateClean({
+        all: isAll,
+        beforeDays: isAll ? void 0 : days,
+        target: options.target
+      });
+      for (const r of propagation.backends) {
+        if (r.status === "ok") {
+          console.log(`  ${r.backend.label}: ${r.detail}`);
+        } else {
+          console.log(`  ${r.backend.label}: skipped \u2014 ${r.detail}`);
+        }
+      }
+    } catch (err) {
+      console.error(`  Propagation failed: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  console.log("\nDone.");
 });
 program.command("recalc").description("Recalculate costs").option("--pricing", "Recalculate using latest pricing").action(() => {
   const db = createDatabase(DB_PATH2);
@@ -9351,7 +9939,7 @@ function hasWidget() {
 }
 function buildPm2Config(includeWidget) {
   const wrapperPath = join15(AIUSAGE_DIR, "pm2-server.cjs");
-  writeFileSync6(wrapperPath, [
+  writeFileSync7(wrapperPath, [
     `// Auto-generated by aiusage pm2-start \u2014 do not edit`,
     `const { execSync, spawn } = require('child_process')`,
     `const { dirname, join } = require('path')`,
@@ -9398,7 +9986,7 @@ program.command("pm2-setup").description("Generate ecosystem.config.cjs for PM2
   const includeWidget = options.serverOnly ? false : hasWidget();
   const config = buildPm2Config(includeWidget);
   const configPath = join15(AIUSAGE_DIR, "ecosystem.config.cjs");
-  writeFileSync6(configPath, config, "utf-8");
+  writeFileSync7(configPath, config, "utf-8");
   console.log(`Config created: ${configPath}`);
   if (!includeWidget) {
     console.log("Note: aiusage-widget not found, only server is configured.");
@@ -9408,7 +9996,7 @@ program.command("pm2-start").description("Setup and start PM2 background service
   const includeWidget = options.serverOnly ? false : hasWidget();
   const config = buildPm2Config(includeWidget);
   const configPath = join15(AIUSAGE_DIR, "ecosystem.config.cjs");
-  writeFileSync6(configPath, config, "utf-8");
+  writeFileSync7(configPath, config, "utf-8");
   console.log(`Config: ${configPath}`);
   try {
     execSync5(`pm2 start "${configPath}"`, { stdio: "inherit" });