worktrust 0.6.10 → 0.6.11

package/README.md

@@ -62,6 +62,12 @@ curl -fsSO https://app.worktrust.io/counter/worktrust.mjs && node worktrust.mjs
    same way as Hermes: clocks, roles, models and token counts, never a message. OpenClaw's Talk
    sessions are sent as voice, its chat-app sessions as remote; subagents and scheduled runs are
    not counted.
+9. **Cursor and GitHub Copilot in VS Code, read in place.** Cursor's chats are read from its own database
+   (`User/globalStorage/state.vscdb`), each message's type, clock, model and token counts through SQLite's own
+   `json_extract`, never the text. Copilot's are read from VS Code's `chatSessions` files: each request's two clocks
+   (asked, answered), its model and its token counts; the messages and responses are parsed with the file and never
+   kept or sent. Neither app runs a hook WorkTrust can give it, so the WorkTrust door, which both start when they
+   open, starts the session hook in the background, at most once an hour.
 
 ```
 npx worktrust history       send this computer's earlier sessions later (asks first)
@@ -94,7 +100,7 @@ which would delete every password on the computer, and many people rightly keep
 
 | | |
 |---|---|
-| **Reads** | Which AI apps are installed (the settings folders of Claude Code, Codex, Cursor, Gemini CLI, Antigravity, VS Code, Windsurf, Hermes Agent, Goose, OpenCode, OpenClaw). Afterwards, the session hook reads Claude Code's, Codex's and Antigravity's session files and the session databases of Hermes, Goose, OpenCode and OpenClaw on this computer to measure durations and token counts. |
+| **Reads** | Which AI apps are installed (the settings folders of Claude Code, Codex, Cursor, Gemini CLI, Antigravity, VS Code, Windsurf, Hermes Agent, Goose, OpenCode, OpenClaw), and the chats Cursor and Copilot keep (clocks, models and token counts only). Afterwards, the session hook reads Claude Code's, Codex's and Antigravity's session files and the session databases of Hermes, Goose, OpenCode and OpenClaw on this computer to measure durations and token counts. |
 | **Writes** | The key file (above). In each AI app's MCP settings (`~/.claude.json` through `claude mcp`, `~/.cursor/mcp.json`, `~/.codex/config.toml`, `~/.gemini/settings.json`, `~/.gemini/config/mcp_config.json` (Antigravity), VS Code's `mcp.json`, Windsurf's `mcp_config.json`, Hermes's and Goose's `config.yaml`, OpenCode's `opencode.json`, OpenClaw through `openclaw mcp set`) a WorkTrust entry that runs the local bridge, with no key in it; three hooks in `~/.claude/settings.json`; the bridge, the hook and the counter in `~/.worktrust/`. |
 | **Sends, to pair** | This computer's system (macOS, Windows, Linux) and host name. WorkTrust also records the network address the request arrives from, as a security record kept 90 days and seen only by WorkTrust staff (to answer a theft or fraud report). |
 | **Sends, afterwards** | Durations, token counts, model names, one layer keyword (frontend, backend …), counts of how you work. |

package/log-session.mjs

@@ -202,7 +202,7 @@ const excluded = (path) => excludes.some((text) => text && path.includes(text));
  */
 const { CODEX_ROLLOUT = /(?!)/, codexLines, codexRolloutFiles = function* () {}, codexCwd = () => null, ANTIGRAVITY_TRANSCRIPT = /(?!)/, antigravityLines, antigravityRoots = () => [], antigravityTranscripts = function* () {}, antigravityContext = () => ({}), rememberAntigravity = () => null } = (await import("./transcript-readers.mjs").catch(() => null)) ?? {};
 const { DATABASE_SESSION = /(?!)/, databaseLines = () => null, databaseSessions = function* () {} } = (await import("./session-databases.mjs").catch(() => null)) ?? {};
-const DATABASE_CLIENTS = ["hermes", "goose", "opencode", "openclaw"]; // the registry's keys, the name each line carries
+const DATABASE_CLIENTS = ["hermes", "goose", "opencode", "openclaw", "cursor", "copilot"]; // the registry's keys, the name each line carries
 const READER_FILES = ["transcript-readers.mjs", "session-databases.mjs"];
 /** The readers go where the hook and the counter run: copied from beside this file, else (or for a newer counter) from the deployment. */
 async function installReaders(origin, fromNetwork = false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktrust",
-  "version": "0.6.10",
+  "version": "0.6.11",
   "description": "Couple this computer to WorkTrust: approve a code in your browser, and every AI app here reports what you built. Metadata only, no dependencies.",
   "type": "module",
   "bin": {

package/session-databases.mjs

@@ -8,7 +8,7 @@
  * like transcript-readers.mjs; without it, or without node:sqlite, these clients are not read and nothing else changes.
  */
 import { createRequire } from "node:module";
-import { readdirSync, statSync } from "node:fs";
+import { readFileSync, readdirSync, statSync } from "node:fs";
 import * as zlib from "node:zlib"; // zstd since Node 22.15; older Node reads OpenClaw's uncompressed rows only
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
@@ -288,6 +288,144 @@ export function openclawLines(pseudo) {
 }
 // ── end openclaw session reader ──
 
+// ── cursor session reader ──
+/**
+ * CURSOR, READ FROM ITS OWN DATABASE (2026-10-06, the owner: "a person who works in Cursor all day has no measured
+ * hours"). Cursor keeps every chat ("composer") in one SQLite file, `User/globalStorage/state.vscdb` (~/Library/Application
+ * Support/Cursor on macOS, %APPDATA%\Cursor on Windows, ~/.config/Cursor on Linux), table cursorDiskKV: `composerData:<id>`
+ * per chat and `bubbleId:<id>:<bubble>` per message. Each message is read through json_extract INSIDE SQLite, its type
+ * (1 the person, 2 the model), its clock and its token counts, so no text ever leaves the database. A model message that
+ * carries a tool call is the loop's own step. The folder a chat belongs to is read from each workspace's own state
+ * (`composer.composerData`); a chat in no workspace has none. Needs node:sqlite (Node 22.5+).
+ */
+const userDirs = (app) => {
+  const base = platform() === "win32" && process.env.APPDATA ? process.env.APPDATA : platform() === "darwin" ? join(homedir(), "Library", "Application Support") : join(homedir(), ".config");
+  return [join(base, app, "User")];
+};
+const folderOf = (uri) => { try { return typeof uri === "string" && uri.startsWith("file://") ? decodeURIComponent(new URL(uri).pathname).replace(/^\/([A-Za-z]:)/, "$1") : null; } catch { return null; } };
+export function cursorHomes(given) { return given ? [given.replace(/^~(?=\/|$)/, homedir())] : userDirs("Cursor"); }
+/** Which folder each composer belongs to, from every workspace's own state. */
+function cursorFolders(home) {
+  const folders = new Map();
+  let dirs = []; try { dirs = readdirSync(join(home, "workspaceStorage")); } catch { return folders; }
+  for (const dir of dirs) {
+    let folder = null; try { folder = folderOf(JSON.parse(readFileSync(join(home, "workspaceStorage", dir, "workspace.json"), "utf8")).folder); } catch { continue; }
+    if (!folder) continue;
+    const db = openDatabase(join(home, "workspaceStorage", dir, "state.vscdb"));
+    if (!db) continue;
+    try {
+      const row = db.prepare("select json_extract(value, '$.allComposers') as ids from ItemTable where key = 'composer.composerData'").get();
+      for (const one of JSON.parse(row?.ids ?? "[]")) if (one?.composerId) folders.set(String(one.composerId), folder);
+    } catch { /* an older schema */ } finally { db.close(); }
+  }
+  return folders;
+}
+export function* cursorSessions(homes) {
+  for (const home of homes) {
+    const file = join(home, "globalStorage", "state.vscdb");
+    try { if (!statSync(file).isFile()) continue; } catch { continue; }
+    const folders = cursorFolders(home);
+    const db = openDatabase(file);
+    if (!db) continue;
+    try {
+      const rows = db.prepare("select substr(key, 14) as id, json_extract(value, '$.lastUpdatedAt') as last from cursorDiskKV where key like 'composerData:%'").all();
+      for (const row of rows) {
+        if (!/^[A-Za-z0-9_.:-]{1,120}$/.test(String(row.id))) continue;
+        yield { sessionId: String(row.id), file: `cursor:${file}#${row.id}`, cwd: folders.get(String(row.id)) ?? null, writtenAt: Number(row.last) || 0 };
+      }
+    } catch { /* an older or foreign schema: not read */ } finally { db.close(); }
+  }
+}
+export function cursorLines(pseudo) {
+  const { file, id } = splitSession(pseudo);
+  const db = openDatabase(file);
+  if (!db) return null;
+  try {
+    const chat = db.prepare("select json_extract(value, '$.modelConfig.modelName') as model from cursorDiskKV where key = ?").get(`composerData:${id}`);
+    const bubbles = db.prepare(`select json_extract(value, '$.type') as type, json_extract(value, '$.createdAt') as at,
+        json_extract(value, '$.tokenCount.inputTokens') as input, json_extract(value, '$.tokenCount.outputTokens') as output,
+        json_extract(value, '$.toolFormerData') is not null as tool
+      from cursorDiskKV where key > ? and key < ? and json_extract(value, '$.createdAt') is not null`).all(`bubbleId:${id}:`, `bubbleId:${id};`);
+    const model = cleanModel(chat?.model);
+    const lines = [];
+    for (const bubble of bubbles.sort((a, b) => String(a.at).localeCompare(String(b.at)))) {
+      const timestamp = new Date(bubble.at).toISOString();
+      if (Number(bubble.type) === 1) lines.push({ type: "user", timestamp, message: { content: [{ type: "text" }] } });
+      else if (Number(bubble.type) === 2) {
+        const usage = Number(bubble.input) || Number(bubble.output) ? { usage: { input_tokens: Number(bubble.input) || 0, output_tokens: Number(bubble.output) || 0 } } : {};
+        lines.push({ type: "assistant", timestamp, message: { model, ...usage, content: bubble.tool ? [{ type: "tool_use", name: "tool", input: {} }] : [] } });
+      }
+    }
+    return lines;
+  } catch { return null; } finally { db.close(); }
+}
+// ── end cursor session reader ──
+
+// ── copilot session reader ──
+/**
+ * GITHUB COPILOT IN VS CODE (2026-10-06). VS Code keeps each Copilot chat as a file: `chatSessions/<id>.jsonl` under
+ * every workspace's storage (`User/workspaceStorage/<hash>/`, its folder in `workspace.json`) and, for a window with no
+ * folder, under `User/globalStorage/emptyWindowChatSessions/`. A .jsonl file is a log of edits (kind 0 the whole
+ * session, 1 a value set at a path, 2 items appended at a path); an older .json file is the session whole. Each
+ * request is read for its clocks and counts only: when it was asked (`timestamp`, the person's turn) and when the
+ * model finished (`modelState.completedAt`), the model it resolved to and the prompt and output tokens. The messages,
+ * the responses and the tool calls' text are parsed with the file and never kept. Agent mode runs a request's tools
+ * between those two clocks without stamping each step, so under the same rule as every other client that span counts
+ * up to the idle cap, as one gap.
+ */
+export function copilotHomes(given) { return given ? [given.replace(/^~(?=\/|$)/, homedir())] : [...userDirs("Code"), ...userDirs("Code - Insiders")]; }
+export function* copilotSessions(homes) {
+  for (const home of homes) {
+    const places = [];
+    try { for (const dir of readdirSync(join(home, "workspaceStorage"))) places.push({ dir: join(home, "workspaceStorage", dir, "chatSessions"), workspace: join(home, "workspaceStorage", dir, "workspace.json") }); } catch { /* none */ }
+    places.push({ dir: join(home, "globalStorage", "emptyWindowChatSessions"), workspace: null });
+    for (const place of places) {
+      let names = []; try { names = readdirSync(place.dir); } catch { continue; }
+      let cwd = null; if (place.workspace) { try { cwd = folderOf(JSON.parse(readFileSync(place.workspace, "utf8")).folder); } catch { /* none */ } }
+      for (const name of names) {
+        const id = name.replace(/\.jsonl?$/, "");
+        if (!/\.jsonl?$/.test(name) || !/^[A-Za-z0-9_.:-]{1,120}$/.test(id)) continue;
+        let writtenAt = 0; try { writtenAt = statSync(join(place.dir, name)).mtimeMs; } catch { continue; }
+        yield { sessionId: id, file: `copilot:${join(place.dir, name)}#${id}`, cwd, writtenAt };
+      }
+    }
+  }
+}
+/** A session file back into the session: the whole object, or the edit log replayed. */
+function copilotSession(text, jsonl) {
+  if (!jsonl) return JSON.parse(text);
+  let session = null;
+  for (const raw of text.split("\n")) {
+    if (!raw.trim()) continue;
+    let edit; try { edit = JSON.parse(raw); } catch { continue; }
+    if (edit.kind === 0) { session = edit.v; continue; }
+    if (!session || !Array.isArray(edit.k) || edit.k.length === 0) continue;
+    const parent = edit.k.slice(0, -1).reduce((at, key) => (at == null ? at : at[key]), session);
+    const key = edit.k.at(-1);
+    if (parent == null || typeof parent !== "object") continue;
+    if (edit.kind === 1) parent[key] = edit.v;
+    else if (edit.kind === 2) { if (!Array.isArray(parent[key])) parent[key] = []; parent[key].push(...(Array.isArray(edit.v) ? edit.v : [edit.v])); }
+  }
+  return session;
+}
+export function copilotLines(pseudo) {
+  const { file } = splitSession(pseudo);
+  let session; try { session = copilotSession(readFileSync(file, "utf8"), file.endsWith(".jsonl")); } catch { return null; }
+  const lines = [];
+  for (const request of Array.isArray(session?.requests) ? session.requests : []) {
+    const asked = Number(request?.timestamp);
+    if (!Number.isFinite(asked) || asked <= 0) continue;
+    lines.push({ type: "user", timestamp: new Date(asked).toISOString(), message: { content: [{ type: "text" }] } });
+    const done = Number(request?.modelState?.completedAt) || (Number(request?.result?.timings?.totalElapsed) ? asked + Number(request.result.timings.totalElapsed) : 0);
+    if (!done || done < asked) continue;
+    const meta = request?.result?.metadata ?? {};
+    const usage = Number(meta.promptTokens) || Number(meta.outputTokens) ? { usage: { input_tokens: Number(meta.promptTokens) || 0, output_tokens: Number(meta.outputTokens) || 0 } } : {};
+    lines.push({ type: "assistant", timestamp: new Date(done).toISOString(), message: { model: cleanModel(String(meta.resolvedModel ?? request?.modelId ?? "").replace(/^copilot\//, "")), ...usage, content: [] } });
+  }
+  return lines;
+}
+// ── end copilot session reader ──
+
 // ── database clients ──
 /** The clients whose sessions live in a database, one registry: the hook and the counter ask it, not each client. */
 const DATABASE_CLIENTS = {
@@ -295,6 +433,8 @@ const DATABASE_CLIENTS = {
   goose: { homes: gooseHomes, sessions: gooseSessions, lines: gooseLines },
   opencode: { homes: opencodeHomes, sessions: opencodeSessions, lines: opencodeLines },
   openclaw: { homes: openclawHomes, sessions: openclawSessions, lines: openclawLines },
+  cursor: { homes: cursorHomes, sessions: cursorSessions, lines: cursorLines },
+  copilot: { homes: copilotHomes, sessions: copilotSessions, lines: copilotLines },
 };
 export const DATABASE_SESSION = new RegExp(`^(${Object.keys(DATABASE_CLIENTS).join("|")}):.+#[A-Za-z0-9_.:-]{1,120}$`);
 /** Every attended session of every database client; `given` names a client's own home (a test), `onlyGiven` reads no other. */

package/worktrust.mjs

@@ -65,7 +65,7 @@ const command = args.find((arg, at) => !arg.startsWith("--") && !(at > 0 && VALU
 const flag = (name) => { const at = args.indexOf(`--${name}`); return at >= 0 ? args[at + 1] : undefined; };
 const has = (name) => args.includes(`--${name}`);
 /** This CLI's version, said to the door so the app can tell which computer runs an old one (check-cli-package holds it equal to package.json). */
-const CLI_VERSION = "0.6.10";
+const CLI_VERSION = "0.6.11";
 const ORIGIN = (flag("origin") ?? process.env.WORKTRUST_ORIGIN ?? "https://app.worktrust.io").replace(/\/$/, "");
 const MCP = flag("url") ?? process.env.WORKTRUST_MCP_URL ?? `${ORIGIN}/api/mcp`;
 const HOME_DIR = join(homedir(), ".worktrust");
@@ -177,10 +177,14 @@ async function pairByBrowser(host, extra) {
   const state = randomBytes(24).toString("base64url");
   let deliver;
   const answer = new Promise((resolve) => { deliver = resolve; });
+  // Where the browser goes once this terminal has its code (0.6.11, owner 2026-10-06): WorkTrust's own "connected" page in
+  // the house style, not a bare page on 127.0.0.1. Known once the pairing has its code; until then the plain page.
+  let doneUrl = null;
   const server = createServer((request, response) => {
     const url = new URL(request.url ?? "/", "http://127.0.0.1");
     if (url.pathname !== "/callback" || url.searchParams.get("state") !== state || !url.searchParams.get("code")) { response.writeHead(404).end(); return; }
-    response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(DONE_PAGE);
+    if (doneUrl) response.writeHead(303, { location: doneUrl, "cache-control": "no-store" }).end();
+    else response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(DONE_PAGE);
     deliver(url.searchParams.get("code"));
   });
   await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
@@ -189,6 +193,7 @@ async function pairByBrowser(host, extra) {
   if (!pairing) { server.close(); fail(`cannot reach ${ORIGIN}.`); }
   if (pairing.status !== 200) { server.close(); fail(pairing.json.error === "rate_limited" ? "too many attempts from this network; wait a minute." : `pairing refused (${pairing.json.error ?? pairing.status}).`); }
   const { device_code: secret, authorize_url: url, user_code: shown, expires_in: lifetime = 600, features = [] } = pairing.json;
+  doneUrl = `${ORIGIN}/connect/computer/done?code=${encodeURIComponent(shown)}`;
   if (!features.includes("loopback")) { server.close(); fail(`${ORIGIN} is older than this command. Use the command WorkTrust shows under Sources → Add a computer.`); }
   say();
   say(`  Your code:  ${shown}  (the WorkTrust page shows the same; approve only if it matches)`);
@@ -403,8 +408,21 @@ async function freshKey() {
  * the key from the key file, answers on stdout. It names the app that started it (from `initialize`),
  * so WorkTrust still sees Claude Code or Cursor, not the bridge.
  */
+/**
+ * A SWEEP WHEN AN AI APP OPENS THE DOOR (0.6.11, owner 2026-10-06). Cursor and VS Code run no hook WorkTrust can give
+ * them, so the session hook never woke for a person who works there all day; both do start this bridge whenever they
+ * open. So the bridge starts the sweep once, detached and silent (stdout stays the MCP channel), at most once an hour.
+ */
+function sweepAtMostHourly() {
+  const stamp = join(HOME_DIR, "bridge-swept-at");
+  try { if (Date.now() - Number(readFileSync(stamp, "utf8")) < 3_600_000) return; } catch { /* never swept here */ }
+  try { mkdirSync(HOME_DIR, { recursive: true }); writeFileSync(stamp, String(Date.now())); } catch { return; }
+  try { spawn(process.execPath, [fileURLToPath(import.meta.url), "hook"], { detached: true, stdio: "ignore" }).unref(); } catch { /* the next start sweeps */ }
+}
+
 async function bridge() {
   let key = await freshKey();
+  if (key) sweepAtMostHourly();
   const answer = (id, message) => process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32603, message } })}\n`);
   let session = null;
   let agent = "worktrust-bridge";