memhouse 0.18.12 → 0.20.1

package/editors/sessions-log.js

@@ -0,0 +1,349 @@
+'use strict';
+// The normalised session log (plan v4, docs/design/sessions-log.md). An adapter writes each session
+// it reads as a log of sessions-model records (one JSON record per line), appended while the session
+// only grows and rewritten when its history changed. The capture engine reads that log like any
+// transcript, with this one generic derive for every harness.
+//
+// Layout: $MEMHOUSE_HOME/session-logs/<harness>/<encodeURIComponent(harness_path)>/<fileNameFor(...)>.jsonl
+// (not logs/: that holds the daemons' own logs, shipper.log and the rest).
+// — one directory per harness store; the engine takes harness_path from the directory name.
+
+const fs = require('fs');
+const path = require('path');
+
+// Above every bridge derive version (editors/bridge.js): a harness that switches from the bridge to
+// its normaliser keeps its session keys and file keys, so the engine sees an adapter upgrade, and the
+// bridge-era rows (positional m<i> ids) are tombstoned as duplicates of the log's native ones.
+// Every log derive version is at least LOG_VERSION_FLOOR; every bridge version is below it.
+const LOG_VERSION_FLOOR = 1000;
+const LOG_DERIVE_VERSION = 1006;   // 1002: house token split, first-seen times by message_id; 1003: usage records, error/notice parts as events; 1004: the session's birth time (meta.created); 1005: the usage flags input_includes_cache / output_includes_reasoning, and the flags of a harness's unflagged logs; 1006: no derive change: comment wording in the shared capture region
+const LOG_EXT = '.jsonl';
+const LOGS_DIR = 'session-logs';
+
+// ── running totals ────────────────────────────────────────────────────────────────────────────
+// Some stores keep a session's usage only as a running total, overwritten as the session grows (Zed's
+// `cumulative_token_usage`). A normaliser hands it over as `{k: 'usage', running: true, usage_id:
+// <series>, ts?, usage}`. Written as is, it would change in place on every turn, and every change
+// rewrites the whole log. writeLog keeps it as increments instead: `{k: 'usage', usage_id:
+// '<series>#<n>', delta_of: <series>, ts, model?, agent_id?, reason?, usage}`, one appended whenever
+// the total has grown since the increments already in the log. The log only appends, and its
+// increments sum to the store's total without overlapping (sessions-model §2.4 "No overlap"). An
+// increment takes the running record's `ts` as it is when the increment is written: the store's own
+// time for the total (Zed: the thread's last save), so the tokens are dated when they were spent, not
+// when memhouse first read them. A running record without one gives `ts: null` (first seen).
+const RUNNING_COUNTS = ['input', 'output', 'cache_read', 'cache_write', 'reasoning', 'tool', 'cost', 'credits'];
+const isRunning = (r) => !!r && r.k === 'usage' && r.running === true;
+const count0 = (v) => { const x = Number(v); return Number.isFinite(x) && x > 0 ? x : 0; };
+/** An increment line already in the log, parsed; null for any other line. */
+function incrementOf(line) {
+  if (!line.startsWith('{"k":"usage"')) return null;
+  try { const o = JSON.parse(line); return o && typeof o.delta_of === 'string' ? o : null; } catch { return null; }
+}
+/**
+ * The increments to append so that, per series, the log's increments sum to its running total: [] when
+ * nothing grew, null when a total shrank below what the log already holds. A series with no running
+ * total this time keeps the increments it has.
+ */
+function increments(running, have) {
+  const out = [];
+  for (const r of running) {
+    const series = String(r.usage_id);
+    const mine = have.filter((d) => d.delta_of === series);
+    const u = r.usage || {};
+    const grown = {};
+    let any = false;
+    for (const k of RUNNING_COUNTS) {
+      const total = count0(u[k]);
+      const had = mine.reduce((s, d) => s + count0(d.usage && d.usage[k]), 0);
+      if (total < had) return null;
+      grown[k] = total > had ? total - had : null;
+      if (grown[k] !== null) any = true;
+    }
+    if (!any) continue;
+    const fixed = Object.fromEntries(Object.entries(u).filter(([k]) => !RUNNING_COUNTS.includes(k)));
+    out.push({
+      k: 'usage', usage_id: `${series}#${mine.length + 1}`, delta_of: series, ts: Number(r.ts) > 0 ? Number(r.ts) : null,
+      ...(r.model ? { model: r.model } : {}), ...(r.agent_id ? { agent_id: r.agent_id } : {}), ...(r.reason ? { reason: r.reason } : {}),
+      usage: { ...fixed, ...grown },
+    });
+  }
+  return out;
+}
+/** The series whose running total fell below the increments the log already holds for it. */
+function shrunk(running, have) {
+  const out = new Set();
+  for (const r of running) {
+    const series = String(r.usage_id);
+    const mine = have.filter((d) => d.delta_of === series);
+    const u = r.usage || {};
+    if (RUNNING_COUNTS.some((k) => count0(u[k]) < mine.reduce((s, d) => s + count0(d.usage && d.usage[k]), 0))) out.add(series);
+  }
+  return out;
+}
+
+/**
+ * Bring a session's log up to date: 'new' | 'append' | 'rewrite' | 'same'. Running totals among the
+ * records become increments (above). A rewrite keeps the increments the log holds, as they were, while
+ * the totals still cover them, so their rows keep their keys; a total that shrank starts its own
+ * series again from one increment, and every other series keeps its increments.
+ */
+function writeLog(file, records) {
+  const running = records.filter(isRunning);
+  const lines = records.filter((r) => !isRunning(r)).map((r) => JSON.stringify(r));
+  let old = null;
+  try { old = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean); } catch { old = null; }
+  const oldLines = []; const had = [];
+  for (const l of old || []) { const d = incrementOf(l); if (d) had.push({ line: l, rec: d }); else oldLines.push(l); }
+  if (old) {
+    let same = 0;
+    while (same < oldLines.length && same < lines.length && oldLines[same] === lines[same]) same++;
+    const grown = same === oldLines.length ? increments(running, had.map((d) => d.rec)) : null;
+    if (grown) {
+      const add = [...lines.slice(same), ...grown.map((r) => JSON.stringify(r))];
+      if (!add.length) return 'same';
+      fs.appendFileSync(file, add.map((l) => `${l}\n`).join(''));
+      return 'append';
+    }
+  }
+  let kept = had;
+  let grown = increments(running, kept.map((d) => d.rec));
+  if (!grown) {
+    const restart = shrunk(running, had.map((d) => d.rec));
+    kept = had.filter((d) => !restart.has(d.rec.delta_of));
+    grown = increments(running, kept.map((d) => d.rec));
+  }
+  const all = [...lines, ...kept.map((d) => d.line), ...grown.map((r) => JSON.stringify(r))];
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, all.map((l) => `${l}\n`).join(''));
+  fs.renameSync(tmp, file);
+  return old ? 'rewrite' : 'new';
+}
+
+/** The directory of one harness store's logs. */
+function logDir(home, harness, harnessPath) {
+  return path.join(home, LOGS_DIR, harness, encodeURIComponent(harnessPath));
+}
+/**
+ * A session's file name: the URI-encoded id ('.' as %2E), then '@' and the encoded incarnation when
+ * there is one. encodeURIComponent always encodes '@', so a literal '@' only ever separates the two.
+ */
+function fileNameFor(sessionId, incarnation = '') {
+  const enc = (s) => encodeURIComponent(String(s)).replace(/\./g, '%2E');
+  return enc(sessionId) + (incarnation ? `@${enc(incarnation)}` : '') + LOG_EXT;
+}
+function parseFileName(name) {
+  const base = path.basename(name, LOG_EXT);
+  const at = base.indexOf('@');
+  try {
+    return at < 0 ? { session_id: decodeURIComponent(base), incarnation: '' }
+      : { session_id: decodeURIComponent(base.slice(0, at)), incarnation: decodeURIComponent(base.slice(at + 1)) };
+  } catch { return null; }
+}
+function sessionIdOf(name) { const p = parseFileName(name); return p ? p.session_id : null; }
+
+// <derive> ====================================================================================
+// The generic derive of every normalised log. Fingerprinted by misc/capture-test.js: change
+// anything in this region and bump LOG_DERIVE_VERSION.
+function n(v) { const x = Math.trunc(Number(v)); return Number.isFinite(x) && x > 0 ? x : 0; }
+/**
+ * Tokens as the house stores them — the split Claude Code and Codex rows already use (the Anthropic
+ * API's): input WITHOUT cached input, output WITH reasoning, cache reads and writes on their own, so
+ * pricing charges each once. A record says what it counts with two flags (sessions-model §2.4):
+ * `input_includes_cache` true means `input` already counts the cache reads and writes — they come
+ * out of it (Gemini); `output_includes_reasoning` false means `output` leaves the reasoning out — it
+ * goes back in (Gemini, OpenCode v1). A flag that is not a boolean falls back to the record's
+ * `basis`: `net` subtracted cached input and reasoning output (OpenCode) — reasoning goes back into
+ * output; `gross` included both (prompt and completion as billed) — cache reads come out of input.
+ * `anthropic` is already the house split; `unknown`, like a null flag, is stored as given.
+ * A record with neither flag, in a harness's log, takes UNFLAGGED[harness] first.
+ */
+// Logs written before a normaliser set the flags (0.20 pre-releases): the flags its records carry
+// now. Such a log outlives its source (normalise-run keeps the logs of sessions no store lists), so
+// it is never written again and every re-derive reads it as it is.
+const UNFLAGGED = { 'gemini-cli': { input_includes_cache: true, output_includes_reasoning: false } };
+const isFlag = (v) => typeof v === 'boolean';
+function houseTokens(u, harness = '') {
+  if (!u) return null;
+  if (UNFLAGGED[harness] && !isFlag(u.input_includes_cache) && !isFlag(u.output_includes_reasoning)) u = { ...u, ...UNFLAGGED[harness] };
+  const input = n(u.input); const cr = n(u.cache_read); const cw = n(u.cache_write); const rs = n(u.reasoning);
+  const inCache = u.input_includes_cache; const outReasoning = u.output_includes_reasoning;
+  let inTok = input;
+  if (inCache === true) inTok = Math.max(input - cr - cw, 0);
+  else if (inCache !== false && u.basis === 'gross') inTok = Math.max(input - cr, 0);
+  const addReasoning = outReasoning === false || (outReasoning !== true && u.basis === 'net');
+  return {
+    input_tokens: inTok,
+    output_tokens: n(u.output) + (addReasoning ? rs : 0),
+    cache_read_tokens: cr, cache_write_tokens: cw, reasoning_tokens: rs,
+  };
+}
+
+function logDeriveAdapter(harness) {
+  return {
+    harness,
+    deriveVersion: LOG_DERIVE_VERSION,
+    initState() { return { folder: '' }; },
+    unitStart(rec) { return !!rec.obj; },
+    track() {}, closeUnit() {}, openUnit() {}, endReplay() {},
+    process(d, rec) {
+      const o = rec.obj;
+      if (o.k === 'session') {
+        if (o.cwd) { d.a.folder = o.cwd; if (!d.c.meta.folder) d.c.meta.folder = o.cwd; }
+        if (o.title) d.c.meta.title = o.title;
+        if (o.version) { d.a.version = o.version; d.c.meta.version = o.version; }
+        // Birth time: tells a fork from its origin when the copies kept the origin's times (forks.js).
+        if (Number(o.created) > 0) d.c.meta.created = Number(o.created);
+        d.c.meta.links = Array.isArray(o.links) ? o.links : [];
+        return;
+      }
+      // Usage the store records on its own, not on a message (Goose's ledger after /clear or a
+      // truncation, compaction calls): a kind 'usage' row, counted in tokens, never as a message.
+      if (o.k === 'usage') {
+        const tok = houseTokens(o.usage, harness);
+        if (!tok || !(tok.input_tokens || tok.output_tokens || tok.cache_read_tokens || tok.cache_write_tokens || tok.reasoning_tokens)) return;
+        const id = o.usage_id != null && o.usage_id !== '' ? `usage:${o.usage_id}` : `usage:@${rec.pos}`;
+        const row = d.turn(rec, { message_id: id, part_id: '', part_ord: 0, role: 'assistant', kind: 'usage', model: o.model || '', agent_id: o.agent_id || '',
+          ts: d.tsOf(rec, Number(o.ts), id), text: '', extra: o.reason ? { reason: String(o.reason) } : {} });
+        d.revise(row, tok, rec);
+        return;
+      }
+      if (o.k !== 'message') return;
+      // A message without its own time is dated once by its id, so a rewrite of the log keeps its key.
+      const ts = d.tsOf(rec, Number(o.ts), o.message_id);
+      const tok = houseTokens(o.usage, harness);
+      const base = {
+        message_id: String(o.message_id), role: o.role === 'user' ? 'user' : (o.role === 'system' ? 'system' : 'assistant'),
+        model: o.model || '', effort: o.effort || '', parent_id: o.parent_id || '', agent_id: o.agent_id || '',
+        state: o.state && o.state !== 'current' ? String(o.state) : '',
+      };
+      const extra = o.status && o.status !== 'complete' ? { status: o.status } : {};
+      let ord = 0;
+      let first = null;
+      for (const p of o.parts || []) {
+        const pts = d.tsOf(rec, Number(p.ts) || Number(o.ts), o.message_id);
+        const pid = String(p.part_id ?? ord);
+        if (p.kind === 'tool') {
+          const row = d.turn(rec, { ...base, part_id: `${pid}:call`, part_ord: ord++, kind: 'tool_call', ts: pts, text: `${p.tool} ${JSON.stringify(p.args ?? {})}`, extra });
+          first = first || row;
+          d.call(rec, { call_id: p.call_id, message_id: base.message_id, ts: pts, tool_name: p.tool, args: JSON.stringify(p.args ?? {}), model: base.model, agent_id: base.agent_id });
+          if (p.output != null || p.is_error) {
+            d.turn(rec, { ...base, role: 'user', part_id: `${pid}:result`, part_ord: ord++, kind: 'tool_result', ts: pts, text: String(p.output ?? ''), extra });
+            d.result(rec, p.call_id, { ts: pts, is_error: !!p.is_error, result_len: String(p.output ?? '').length });
+          }
+          continue;
+        }
+        // An error or notice part is an event of the message, never a message of its own.
+        const kind = { reasoning: 'thinking', summary: 'summary', file: 'attachment', error: 'event', notice: 'event' }[p.kind] || 'text';
+        const text = p.kind === 'file' ? `${p.media_type || 'file'} ${p.att_sha || p.ref || ''}`.trim() : String(p.text ?? '');
+        const fx = p.kind === 'file' ? { media_type: p.media_type, att_sha: p.att_sha, att_len: p.att_len } : (kind === 'event' ? { notice: p.kind } : {});
+        const row = d.turn(rec, { ...base, part_id: pid, part_ord: ord++, kind, ts: pts, text, extra: { ...extra, ...fx } });
+        first = first || row;
+      }
+      // A message with no parts keeps a header row: its status and usage anchor.
+      if (!first) first = d.turn(rec, { ...base, part_id: '', part_ord: 0, kind: 'none', ts, text: '', extra });
+      if (tok && (tok.input_tokens || tok.output_tokens || tok.cache_read_tokens || tok.cache_write_tokens || tok.reasoning_tokens)) d.revise(first, tok, rec);
+    },
+  };
+}
+
+// </derive> ===================================================================================
+
+/** The capture capability for one harness whose sessions are kept as normalised logs. */
+function logCapture(harness) {
+  const adapter = logDeriveAdapter(harness);
+  return {
+    harness,
+    deriveVersion: LOG_DERIVE_VERSION,
+    sessions(root) {
+      let names = [];
+      try { names = fs.readdirSync(root.dir).filter((x) => x.endsWith(LOG_EXT)); } catch { return []; }
+      const out = [];
+      for (const x of names) {
+        const p = parseFileName(x);
+        if (p && p.session_id) out.push({ harness, session_id: p.session_id, incarnation: p.incarnation, root: root.name, paths: [path.join(root.dir, x)] });
+      }
+      return out;
+    },
+    sourceFiles(session) { return session.paths.map((p) => ({ file_key: path.basename(p), path: p, agent_id: '', role: 'main' })); },
+    attribution: () => ({ agent_type: '', agent_desc: '' }),
+    // Records the engine dates by their first sighting: a message, or a usage record (a running
+    // total's increment), with no time of its own. When a files row is lost, their first sightings
+    // are read back from the archive (restoreFirstSeen), by byte position in the generation the
+    // read starts at. That keeps their keys only while it is the generation they were first seen
+    // in: with the local cache lost too, the read starts at generation 0, and a log rewritten since
+    // has moved its records, so they are re-dated under new keys (a known issue, 0.20 release
+    // notes). An increment of a store that gives its total a time (Zed) carries it, and is not
+    // affected.
+    tsless: (o) => !o || ((o.k === 'message' || o.k === 'usage') && !(Number(o.ts) > 0)),
+    derive: (input) => require('./base').capture.runDerive(adapter, input),
+    adapter,
+  };
+}
+
+/** Capture roots for every store directory under $MEMHOUSE_HOME/logs, with their harness_path. */
+function logRoots(home) {
+  const top = path.join(home, LOGS_DIR);
+  const roots = [];
+  let harnesses = [];
+  try { harnesses = fs.readdirSync(top).filter((h) => /^[a-z0-9][a-z0-9-]{0,40}$/.test(h)); } catch { return roots; }
+  for (const harness of harnesses) {
+    let stores = [];
+    try { stores = fs.readdirSync(path.join(top, harness)); } catch { continue; }
+    for (const enc of stores) {
+      let hp;
+      try { hp = decodeURIComponent(enc); } catch { continue; }
+      const dir = path.join(top, harness, enc);
+      try { if (!fs.statSync(dir).isDirectory()) continue; } catch { continue; }
+      roots.push({ harness, name: path.basename(hp) || 'default', dir, harness_path: hp });
+    }
+  }
+  return roots;
+}
+
+/**
+ * Sub-agents and forks a session started (the origin side of a link) go in the log as `child`
+ * records, `{k: 'child', kind, session_id, evidence, at?}`, each right after the message that names
+ * it, never on the session record. The session record is the log's first line: a child there
+ * changes it with every sub-agent spawned, and each change rewrites the whole log, re-archiving
+ * and re-emitting every row (misc/rewrite-freq.js measured a Zed thread with a sub-agent every five
+ * turns at 5.4x the archive of the same thread without). A normaliser returns its records through
+ * this, with `children` on the session record and, on each child, `after`: the id of the message
+ * it was found in, where it knows one.
+ * - A child whose message is not in the log (held back) waits for it.
+ * - One without `after` follows the first message whose parts name its session id.
+ * - One that no message names stays on the session record, and rewrites the log once, when it
+ *   appears.
+ */
+function placeChildren(recs) {
+  if (!Array.isArray(recs) || !recs.length) return recs;
+  const head = recs[0];
+  if (!head || head.k !== 'session' || !('children' in head)) return recs;
+  const ids = new Set(recs.filter((r) => r && r.k === 'message').map((r) => String(r.message_id)));
+  const naming = (sid) => {
+    const m = recs.find((r) => r && r.k === 'message' && JSON.stringify(r.parts || []).includes(sid));
+    return m ? String(m.message_id) : null;
+  };
+  const byMsg = new Map(); const keep = [];
+  for (const c of Array.isArray(head.children) ? head.children : []) {
+    const { after, ...child } = c;
+    const m = after != null && after !== '' ? String(after) : naming(String(c.session_id));
+    if (m == null) { keep.push(child); continue; }
+    if (!ids.has(m)) continue;
+    if (!byMsg.has(m)) byMsg.set(m, []);
+    byMsg.get(m).push({ k: 'child', ...child });
+  }
+  const { children, ...rest } = head;
+  const out = [keep.length ? { ...rest, children: keep } : rest];
+  for (const r of recs.slice(1)) {
+    out.push(r);
+    const id = r && r.k === 'message' ? String(r.message_id) : null;
+    if (id !== null && byMsg.has(id)) { out.push(...byMsg.get(id)); byMsg.delete(id); }
+  }
+  return out;
+}
+
+module.exports = {
+  placeChildren,
+  writeLog, logDir, logRoots, logCapture, logDeriveAdapter, houseTokens, fileNameFor, LOG_VERSION_FLOOR, parseFileName, sessionIdOf, LOG_DERIVE_VERSION,
+};

package/editors/sqlite.js

@@ -4,7 +4,7 @@
 // This was `better-sqlite3`, a native module whose prebuilt binary arrives through an
 // npm install script — and npm >= 12 blocks install scripts by default, so a plain
 // `npm i -g memhouse` left no binding at all. Those five adapters then read ZERO
-// sessions and looked exactly like editors the pilot does not have. The fix was a flag
+// sessions and looked exactly like editors the user does not have. The fix was a flag
 // (`--allow-scripts=better-sqlite3`) that had to be typed on every install and every
 // upgrade, was never remembered by npm, and produced no error when omitted.
 //
@@ -18,6 +18,10 @@
 // need no SQLite at all down with the five that do, and `discover` would report zero
 // editors. Lazy, that throw lands inside each adapter's own try/catch and is reported
 // through adapter-errors like any other unreadable store.
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+
 let DatabaseSync = null;
 
 /**
@@ -33,9 +37,32 @@ let DatabaseSync = null;
  */
 function openReadOnly(file) {
   if (!DatabaseSync) ({ DatabaseSync } = require('node:sqlite'));
+  // A WAL-mode store opened read-only CREATES <db>-wal and <db>-shm when they are absent, and
+  // they stay after close (measured, node:sqlite in Node 24.17): a reader writing into the
+  // editor's own folder, on every pass. With a -wal present (the editor is writing, or left one)
+  // a plain read-only open is the only correct read: the WAL holds pages the main file lacks.
+  // Without one, the main file is the whole database, and immutable=1 reads it creating nothing.
+  //
+  // immutable=1 also turns locking off, so it is only for a WAL database: a rollback-journal one
+  // (Zed's threads.db) is rewritten in place under a lock, and an immutable read during a save is
+  // torn — measured: 3,525 "malformed" and 304 corrupt reads in 10,625 against a live writer, none
+  // with the plain open, which in rollback mode creates no file. The header says which (byte 18:
+  // 1 rollback, 2 WAL).
+  if (!fs.existsSync(file)) throw new Error(`unable to open database file: ${file}`);
+  if (!fs.existsSync(`${file}-wal`) && isWalHeader(file)) return new DatabaseSync(`${pathToFileURL(path.resolve(file)).href}?immutable=1`, { readOnly: true });
   return new DatabaseSync(file, { readOnly: true });
 }
 
+/** True when the file's SQLite header says WAL mode (file format write version, byte 18, is 2). */
+function isWalHeader(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const b = Buffer.alloc(20);
+    return fs.readSync(fd, b, 0, 20, 0) === 20 && b.toString('latin1', 0, 15) === 'SQLite format 3' && b[18] === 2;
+  } catch { return false; } finally { if (fd !== undefined) fs.closeSync(fd); }
+}
+
 /**
  * A column's value as text, whether SQLite handed back TEXT or BLOB.
  *

package/editors/vscode.js

@@ -317,77 +317,6 @@ function getMessages(chat) {
   return messages;
 }
 
-// ============================================================
-// Usage / quota data from GitHub Copilot internal API
-// ============================================================
-
-function getCopilotToken() {
-  const appsPath = path.join(os.homedir(), '.config', 'github-copilot', 'apps.json');
-  try {
-    if (!fs.existsSync(appsPath)) return null;
-    const data = JSON.parse(fs.readFileSync(appsPath, 'utf-8'));
-    // Pick the first available oauth_token
-    for (const entry of Object.values(data)) {
-      if (entry.oauth_token) return { token: entry.oauth_token, user: entry.user || null };
-    }
-  } catch {}
-  return null;
-}
-
-function fetchCopilotStatus(token) {
-  return new Promise((resolve) => {
-    const https = require('https');
-    const req = https.get('https://api.github.com/copilot_internal/v2/token', {
-      headers: {
-        'Authorization': `token ${token}`,
-        'Accept': 'application/json',
-        'User-Agent': 'agentlytics/1.0',
-      },
-      timeout: 10000,
-    }, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        try { resolve(JSON.parse(data)); } catch { resolve(null); }
-      });
-    });
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
-  });
-}
-
-async function getUsage() {
-  const { isSubscriptionAccessAllowed } = require('./base');
-  if (!isSubscriptionAccessAllowed()) return null;
-  const creds = getCopilotToken();
-  if (!creds) return null;
-
-  const status = await fetchCopilotStatus(creds.token);
-  if (!status || status.message) return null;
-
-  return {
-    source: 'vscode',
-    plan: {
-      name: status.sku || null,
-      individual: status.individual || false,
-    },
-    features: {
-      chat: status.chat_enabled || false,
-      codeReview: status.code_review_enabled || false,
-      agentMode: status.agent_mode_auto_approval || false,
-      xcode: status.xcode || false,
-      mcp: status.mcp || false,
-    },
-    limits: {
-      quotas: status.limited_user_quotas || null,
-      resetDate: status.limited_user_reset_date || null,
-    },
-    user: {
-      login: creds.user || null,
-    },
-  };
-}
-
 const labels = { 'vscode': 'VS Code', 'vscode-insiders': 'VS Code Insiders' };
 
 function getArtifacts(folder) {
@@ -412,4 +341,4 @@ function getMCPServers() {
   return results;
 }
 
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers };
+module.exports = { name, labels, getChats, getMessages, getArtifacts, getMCPServers };

package/editors/windsurf.js

@@ -461,148 +461,6 @@ function getMessages(chat) {
   return messages;
 }
 
-// ============================================================
-// Usage / quota data from language server RPC
-// ============================================================
-
-function getDevinApiKey(appNames) {
-  if (!appNames) return null;
-  const names = Array.isArray(appNames) ? appNames : [appNames];
-  const keys = ['windsurfAuthStatus', 'devinAuthStatus'];
-  try {
-    const HOME = os.homedir();
-    for (const appName of names) {
-      let dbPath;
-      switch (process.platform) {
-        case 'darwin':
-          dbPath = path.join(HOME, 'Library', 'Application Support', appName, 'User', 'globalStorage', 'state.vscdb');
-          break;
-        case 'win32':
-          dbPath = path.join(HOME, 'AppData', 'Roaming', appName, 'User', 'globalStorage', 'state.vscdb');
-          break;
-        default:
-          dbPath = path.join(HOME, '.config', appName, 'User', 'globalStorage', 'state.vscdb');
-      }
-      if (!fs.existsSync(dbPath)) continue;
-      const { openReadOnly, textOf } = require('./sqlite');
-      const db = openReadOnly(dbPath);
-      try {
-        for (const key of keys) {
-          const row = db.prepare('SELECT value FROM ItemTable WHERE key = ?').get(key);
-          if (!row) continue;
-          const parsed = JSON.parse(textOf(row.value));
-          if (parsed.apiKey) return parsed.apiKey;
-        }
-      } finally {
-        db.close();
-      }
-    }
-    return null;
-  } catch { return null; }
-}
-
-function getUsage() {
-  const { isSubscriptionAccessAllowed } = require('./base');
-  if (!isSubscriptionAccessAllowed()) return [];
-
-  const results = [];
-
-  for (const variant of VARIANTS) {
-    const ls = getLsForVariant(variant);
-    if (!ls) continue;
-
-    const apiKey = getDevinApiKey(variant.appNames);
-    if (!apiKey) continue;
-    const body = {
-      metadata: {
-        api_key: apiKey,
-        ide_name: variant.id,
-        ide_version: '1.0.0',
-        extension_version: '1.0.0',
-        locale: 'en',
-      },
-    };
-
-    const resp = callRpc(ls.port, ls.csrf, 'GetUserStatus', body, ls.extCsrf);
-    if (!resp || !resp.userStatus) continue;
-
-    const us = resp.userStatus;
-    const ps = us.planStatus || {};
-    const pi = ps.planInfo || {};
-    const modelConfigs = (us.cascadeModelConfigData || {}).clientModelConfigs || [];
-
-    const models = modelConfigs.map((m) => {
-      const qi = m.quotaInfo || {};
-      return {
-        label: m.label || null,
-        model: m.modelOrAlias?.model || null,
-        remainingFraction: qi.remainingFraction != null ? qi.remainingFraction : null,
-        resetTime: qi.resetTime || null,
-        supportsImages: m.supportsImages || false,
-      };
-    });
-
-    // Raw values are in internal units (÷100 for display credits)
-    const promptAlloc = (ps.availablePromptCredits || 0) / 100;
-    const promptUsed = (ps.usedPromptCredits || 0) / 100;
-    const flexAlloc = (ps.availableFlexCredits || 0) / 100;
-    const flexUsed = (ps.usedFlexCredits || 0) / 100;
-    const flowAlloc = (ps.availableFlowCredits || 0) / 100;
-    const monthlyDisplay = (pi.monthlyPromptCredits || 0) / 100;
-
-    const remainingPrompt = Math.max(0, promptAlloc - promptUsed);
-    const remainingFlex = Math.max(0, flexAlloc - flexUsed);
-    const totalRemaining = remainingPrompt + remainingFlex;
-
-    // Credit multipliers per model
-    const creditMultipliers = (pi.creditMultiplierOverrides || []).reduce((acc, entry) => {
-      const model = entry.modelOrAlias?.model;
-      if (model && entry.creditMultiplier != null) acc[model] = entry.creditMultiplier;
-      return acc;
-    }, {});
-
-    results.push({
-      source: variant.id,
-      plan: {
-        name: pi.planName || null,
-        tier: pi.teamsTier || null,
-        monthlyPromptCredits: monthlyDisplay,
-        monthlyFlowCredits: (pi.monthlyFlowCredits || 0) / 100,
-        canBuyMoreCredits: pi.canBuyMoreCredits || false,
-      },
-      usage: {
-        promptCredits: { allocated: promptAlloc, used: promptUsed, remaining: remainingPrompt },
-        flexCredits: { allocated: flexAlloc, used: flexUsed, remaining: remainingFlex },
-        flowCredits: { allocated: flowAlloc },
-        totalRemainingCredits: totalRemaining,
-      },
-      billingCycle: {
-        start: ps.planStart || null,
-        end: ps.planEnd || null,
-      },
-      topUp: ps.topUpStatus ? {
-        monthlyAmount: ps.topUpStatus.monthlyTopUpAmount || null,
-        increment: ps.topUpStatus.topUpIncrement || null,
-      } : null,
-      features: {
-        webSearch: pi.cascadeWebSearchEnabled || false,
-        browser: pi.browserEnabled || false,
-        knowledgeBase: pi.knowledgeBaseEnabled || false,
-        autoRunCommands: pi.cascadeCanAutoRunCommands || false,
-        commitMessages: pi.canGenerateCommitMessages || false,
-      },
-      models,
-      creditMultipliers,
-      user: {
-        name: us.name || null,
-        email: us.email || null,
-      },
-    });
-  }
-
-  return results.length > 0 ? results : null;
-}
-
 function resetCache() { _lsCache = null; }
 
 const labels = { 'devin': 'Devin', 'devin-next': 'Devin Next' };
@@ -631,4 +489,4 @@ function getMCPServers() {
   return results;
 }
 
-module.exports = { name, sources, legacySources, labels, getChats, getMessages, resetCache, getUsage, getArtifacts, getMCPServers };
+module.exports = { name, sources, legacySources, labels, getChats, getMessages, resetCache, getArtifacts, getMCPServers };