ccdesk 0.1.0 → 0.2.0

package/dist/server/scan/usage.js

@@ -1,41 +1,83 @@
 import { open, realpath, stat } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
+import { storeDirName } from "../../shared/memory.js";
 import {} from "../../shared/types.js";
 import {} from "./env.js";
-import { isDir, isRecord, isWithin, leadsToSecret, listDir, wildcard, worktrees } from "./files.js";
-import { storeDirName } from "./memory.js";
+import { isCredentials, isDir, isRecord, isWithin, listDir, wildcard, worktrees } from "./files.js";
 import { namesTool, parseRule } from "./tools.js";
 /**
- * Transcripts already counted, by path, so reopening a directory reads only what was added. It
- * keeps the commands of every directory opened since ccdesk started, in memory only.
+ * Transcripts already counted, by path, so reopening a directory reads only what was added. Kept
+ * in memory only, least recently counted first; once they hold more than MAX_CACHED_CALLS calls,
+ * the oldest are dropped and read again when needed.
  */
 const transcripts = new Map();
+/** Roughly how many calls the cache keeps, beyond those of the directory counted last. */
+export const MAX_CACHED_CALLS = 100_000;
 /** A transcript is read in parts this size, so one huge file never becomes one huge string. */
 const CHUNK = 8 * 1024 * 1024;
 let queue = Promise.resolve();
 /** Requests waiting their turn, so a burst of the same request runs once. */
 const waiting = new Map();
+/** How long one count may take before it stops; what it read by then stays counted. */
+const TIME_LIMIT_MS = 60_000;
+/** A count that stopped before it finished, because it took too long or nobody wanted it. */
+export class CountStopped extends Error {
+}
 /**
  * Counts the tool calls in the sessions started in `dir`, or anywhere in its repository and its
  * worktrees, since rules at a repository's root apply there too (docs: permissions#permission-system).
  * Subagents are included. It also counts the calls you approved or refused by hand, which Claude
  * Code records on each call's result as `permissionDecision` (not documented; older transcripts
- * lack it), and how many calls each rule covers. Requests run one at a time, since they share the cache.
+ * lack it), and how many calls each rule covers. Requests run one at a time, since they share the
+ * cache. A count stops when every `signal` it was asked with aborts, or after `timeLimitMs`: it
+ * rejects with CountStopped and the next one starts, even if a read of the stopped count never
+ * returns.
  */
-export function readUsage(env, dir, rules) {
-    const key = JSON.stringify([env.claudeDir, resolve(dir), rules]);
-    const queued = waiting.get(key);
-    if (queued)
-        return queued;
-    const run = queue.then(() => {
-        waiting.delete(key);
-        return count(env, resolve(dir), rules);
-    });
-    waiting.set(key, run);
-    queue = run.catch(() => undefined);
-    return run;
+export function readUsage(env, dir, rules, { signal, timeLimitMs = TIME_LIMIT_MS, maxCachedCalls = MAX_CACHED_CALLS, } = {}) {
+    const key = JSON.stringify([env.claudeDir, resolve(dir), rules, timeLimitMs, maxCachedCalls]);
+    let run = waiting.get(key);
+    if (!run) {
+        const stop = new AbortController();
+        const promise = queue.then(() => {
+            waiting.delete(key);
+            const during = AbortSignal.any([stop.signal, AbortSignal.timeout(timeLimitMs)]);
+            // A stopped count answers right away, even while one of its reads never returns.
+            const stopped = new Promise((_, fail) => {
+                const onStop = () => fail(stoppedBecause(during));
+                if (during.aborted)
+                    onStop();
+                else
+                    during.addEventListener("abort", onStop, { once: true });
+            });
+            return Promise.race([count(env, resolve(dir), rules, during, maxCachedCalls), stopped]);
+        });
+        run = { promise, stop, waiters: 0 };
+        waiting.set(key, run);
+        // The queue moves on when the count settles or stops: a stopped count changes nothing more.
+        queue = promise.catch(() => undefined);
+    }
+    const current = run;
+    if (signal?.aborted)
+        return current.promise;
+    current.waiters++;
+    signal?.addEventListener("abort", () => {
+        if (--current.waiters === 0)
+            current.stop.abort();
+    }, { once: true });
+    return current.promise;
 }
-async function count(env, dir, rules) {
+function stoppedBecause(signal) {
+    return new CountStopped(signal.reason instanceof DOMException && signal.reason.name === "TimeoutError"
+        ? "Counting tool calls took too long and stopped; what was read is kept, so the next count continues."
+        : "The count was no longer wanted.");
+}
+/** Throws once a count has to stop, before it changes anything else. */
+function checkStopped(signal) {
+    if (signal.aborted)
+        throw stoppedBecause(signal);
+}
+async function count(env, dir, rules, signal, maxCachedCalls) {
+    checkStopped(signal);
     const checkouts = await worktrees(dir);
     // $HOME may end in a slash or be a link, while git prints the resolved path.
     const homes = new Set([
@@ -50,6 +92,7 @@ async function count(env, dir, rules) {
     const storeNames = await listDir(projects);
     const taken = new Set();
     const calls = [];
+    const counted = new Set();
     let sessions = 0;
     for (const folder of folders) {
         const own = storeDirName(folder);
@@ -65,19 +108,23 @@ async function count(env, dir, rules) {
                 if (taken.has(file))
                     continue;
                 // A subagent's session decides; one whose session file is gone goes by its own start.
-                const start = (await transcript(session))?.startCwd ?? (await transcript(file))?.startCwd;
+                const start = (await transcript(env, session, signal))?.startCwd ??
+                    (await transcript(env, file, signal))?.startCwd;
                 if (start ? !isWithin(folder, start) : name !== own)
                     continue;
                 taken.add(file);
-                calls.push(...((await transcript(file))?.calls ?? []));
+                counted.add(file);
+                calls.push(...((await transcript(env, file, signal))?.calls ?? []));
                 if (file === session)
                     sessions++;
             }
+            checkStopped(signal);
             for (const path of transcripts.keys())
                 if (path.startsWith(store + sep) && !files.has(path))
                     transcripts.delete(path);
         }
     }
+    trimCache(counted, maxCachedCalls);
     return {
         sessions,
         repository,
@@ -87,6 +134,18 @@ async function count(env, dir, rules) {
         matches: Object.fromEntries(rules.map((r) => [r.rule, matchCount(r, calls)])),
     };
 }
+/** Drops the least recently counted transcripts over the limit, keeping those just counted. */
+function trimCache(counted, maxCalls) {
+    let total = 0;
+    for (const known of transcripts.values())
+        total += known.calls.length;
+    for (const [path, known] of transcripts) {
+        if (total <= maxCalls || counted.has(path))
+            return;
+        transcripts.delete(path);
+        total -= known.calls.length;
+    }
+}
 /** A store's transcripts, each with the session it belongs to: itself, or a subagent's session. */
 async function transcriptsIn(store) {
     const files = new Map();
@@ -100,32 +159,39 @@ async function transcriptsIn(store) {
     }
     return files;
 }
-/** One transcript, read up to its end; one that cannot be read keeps what was read before. */
-async function transcript(file) {
-    if (await leadsToSecret(file))
+/**
+ * One transcript, read up to its end; one that cannot be read keeps what was read before, and one
+ * whose count stops keeps the whole lines read so far.
+ */
+async function transcript(env, file, signal) {
+    if (await isCredentials(env, file))
         return null;
     const info = await stat(file).catch(() => null);
+    checkStopped(signal);
     if (!info?.isFile())
         return null;
     let known = transcripts.get(file);
-    if (!known || info.size < known.offset) {
+    if (!known || info.size < known.offset)
         known = { size: 0, mtimeMs: 0, offset: 0, calls: [], byId: new Map() };
-        transcripts.set(file, known);
-    }
+    // Set again so the map stays in order of last use.
+    transcripts.delete(file);
+    transcripts.set(file, known);
     if (known.size === info.size && known.mtimeMs === info.mtimeMs)
         return known;
     try {
-        await readFrom(file, known, info.size);
+        await readFrom(file, known, info.size, signal);
         known.size = info.size;
         known.mtimeMs = info.mtimeMs;
     }
-    catch {
+    catch (error) {
+        if (error instanceof CountStopped)
+            throw error;
         // Gone or unreadable since the stat: keep what was counted; the offset still marks it.
     }
     return known;
 }
 /** Reads whole lines from the offset up to `size`; a line still being written is read next time. */
-async function readFrom(file, known, size) {
+async function readFrom(file, known, size, signal) {
     const handle = await open(file, "r");
     try {
         let carried = Buffer.alloc(0);
@@ -133,6 +199,8 @@ async function readFrom(file, known, size) {
         while (position < size) {
             const chunk = Buffer.alloc(Math.min(CHUNK, size - position));
             const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
+            // Checked before the cache changes: a later count may already be reading this file.
+            checkStopped(signal);
             if (bytesRead === 0)
                 break;
             position += bytesRead;
@@ -198,17 +266,23 @@ function read(line, transcript) {
     }
 }
 function callOf(tool, input, at) {
-    const call = { tool, at };
-    if ((tool === "Bash" || tool === "Monitor") && typeof input.command === "string")
-        call.command = input.command;
+    const command = (tool === "Bash" || tool === "Monitor") && typeof input.command === "string"
+        ? input.command
+        : undefined;
+    let host;
     if (tool === "WebFetch" && typeof input.url === "string") {
         try {
-            call.host = new URL(input.url).hostname.replace(/\.$/, "");
+            host = new URL(input.url).hostname.replace(/\.$/, "");
         }
         catch {
             // Not a URL: no domain rule can match it.
         }
     }
+    const call = { tool, at, rule: ruleFor(tool, command, host) };
+    if (command !== undefined)
+        call.commands = everyCommandIn(command);
+    if (host !== undefined)
+        call.host = host;
     return call;
 }
 function toolUsage(calls) {
@@ -235,9 +309,8 @@ function approvals(calls, rules) {
     for (const c of calls) {
         if (c.byYou !== true)
             continue;
-        const rule = ruleFor(c);
-        if (rule)
-            groups.set(rule, [...(groups.get(rule) ?? []), c]);
+        if (c.rule)
+            groups.set(c.rule, [...(groups.get(c.rule) ?? []), c]);
     }
     const refused = calls.filter((c) => c.byYou === false);
     const out = [];
@@ -307,13 +380,13 @@ const PATH_TOOLS = new Set(["Read", "Edit", "Write", "NotebookEdit", "Glob", "Gr
  * permissions#process-wrappers) and file tools. A rule takes no other words from a command, so
  * arguments never leave the server.
  */
-function ruleFor(call) {
-    if (call.tool === "Bash") {
-        if (call.command === undefined || /[`$<>(){}]/.test(call.command))
+function ruleFor(tool, command, host) {
+    if (tool === "Bash") {
+        if (command === undefined || /[`$<>(){}]/.test(command))
             return null;
-        if (/^\s*\w+=/.test(call.command))
+        if (/^\s*\w+=/.test(command))
             return null;
-        const parts = subcommands(call.command);
+        const parts = subcommands(command);
         if (parts.length !== 1)
             return null;
         const [program, ...rest] = (parts[0] ?? "").split(/\s+/);
@@ -324,11 +397,11 @@ function ruleFor(call) {
         const sub = SUBCOMMANDS[program]?.find((words) => words.split(" ").every((word, i) => rest[i] === word));
         return sub ? `Bash(${program} ${sub} *)` : null;
     }
-    if (call.tool === "WebFetch")
-        return call.host ? `WebFetch(domain:${call.host})` : null;
-    if (PATH_TOOLS.has(call.tool) || call.tool === "PowerShell" || call.tool === "Monitor")
+    if (tool === "WebFetch")
+        return host ? `WebFetch(domain:${host})` : null;
+    if (PATH_TOOLS.has(tool) || tool === "PowerShell" || tool === "Monitor")
         return null;
-    return call.tool;
+    return tool;
 }
 const SEPARATORS = /&&|\|\||\|&|[;|&\n]/;
 /** docs: permissions#process-wrappers */
@@ -416,7 +489,7 @@ function matcherFor({ list, rule }) {
         const pattern = bashPattern(specifier);
         if (pattern === null)
             return null;
-        return (c) => c.command !== undefined && everyCommandIn(c.command).some(pattern);
+        return (c) => c.commands?.some(pattern) === true;
     }
     if (tool === "WebFetch" && specifier.startsWith("domain:")) {
         const host = wildcard(specifier.slice(7).replace(/\.$/, ""), "i");

package/dist/server/schema.js

@@ -0,0 +1,15 @@
+import { Ajv } from "ajv";
+export const ajv = new Ajv({ allErrors: true, strict: false });
+/**
+ * What `validate` found wrong with `value`, each led by where: `label` and the path inside it, such
+ * as `sandbox.network`.
+ */
+export function schemaErrors(validate, value, label) {
+    if (validate(value))
+        return [];
+    return (validate.errors ?? []).map((e) => {
+        const where = [label, ...e.instancePath.split("/")].filter(Boolean).join(".");
+        const allowed = e.keyword === "enum" ? `: ${e.params.allowedValues.join(", ")}` : "";
+        return `${where} ${e.message ?? "is invalid"}${allowed}`;
+    });
+}

package/dist/server/secrets.js

@@ -0,0 +1,63 @@
+import { isRecord, redactSecrets, shownUrl } from "./scan/files.js";
+/**
+ * Helpers for the values ccdesk hides. What is hidden is decided only by redactSecrets; these
+ * compare a value with its redacted form.
+ */
+/** A value as ccdesk shows it: JSON with hidden values as •••. */
+export function shown(value) {
+    return `${JSON.stringify(redactSecrets(value), null, 2)}\n`;
+}
+/** Every value redactSecrets changes, with where it is, what it is, and how it is shown. */
+function hiddenIn(value) {
+    const found = [];
+    // redactSecrets keeps every key and list length, so the two can be walked side by side.
+    const walk = (raw, shownValue, path) => {
+        if (Array.isArray(raw) && Array.isArray(shownValue)) {
+            for (const [i, inner] of raw.entries())
+                walk(inner, shownValue[i], [...path, i]);
+        }
+        else if (isRecord(raw) && isRecord(shownValue))
+            for (const [key, inner] of Object.entries(raw))
+                walk(inner, shownValue[key], [...path, key]);
+        else if (raw !== shownValue)
+            found.push({ path, raw, shown: shownValue });
+    };
+    walk(value, redactSecrets(value), []);
+    return found;
+}
+export function hasHiddenValues(value) {
+    return hiddenIn(value).length > 0;
+}
+/**
+ * A fingerprint of the hidden values in a JSON file, so a restore can tell whether they changed.
+ * Null for a file that is not valid JSON.
+ */
+export function hiddenValues(text) {
+    try {
+        const data = text === null ? null : JSON.parse(text);
+        return JSON.stringify(hiddenIn(data).map(({ path, raw }) => [path, raw]));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The secret text in a value, to take out of a message that may quote it: an env or header value
+ * or a hidden argument whole, the part after `=` of `--token=value`, and a URL's user name,
+ * password and query. Longest first, so a secret that contains another is taken out whole.
+ */
+export function secretTexts(value) {
+    const found = hiddenIn(value).flatMap(({ raw, shown }) => {
+        if (typeof raw !== "string")
+            return [];
+        if (shown === "•••")
+            return [raw];
+        if (typeof shown === "string" && shown.endsWith("=•••"))
+            return [raw.slice(raw.indexOf("=") + 1)];
+        if (shownUrl(raw) === raw)
+            return [];
+        const url = URL.parse(raw);
+        return [url?.username, url?.password, url?.search.slice(1)];
+    });
+    return found.filter((s) => !!s).sort((a, b) => b.length - a.length);
+}