ccdesk 0.0.0-stage → 0.1.0

package/dist/server/scan/projects.js

@@ -0,0 +1,100 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import {} from "../../shared/types.js";
+import {} from "./env.js";
+import { isDir, isRecord, leadsToSecret, listDir } from "./files.js";
+import { readMemoryStore, storeDirName } from "./memory.js";
+/** Directories Claude Code has been used in: its project stores, `~/.claude.json`, and the launch directory. */
+export async function listProjects(env, claudeJson, launchDir) {
+    const byPath = new Map();
+    const storesRoot = join(env.claudeDir, "projects");
+    const knownPaths = isRecord(claudeJson?.projects) ? Object.keys(claudeJson.projects) : [];
+    for (const name of await listDir(storesRoot)) {
+        const storeDir = join(storesRoot, name);
+        if (!(await isDir(storeDir)))
+            continue;
+        const sessions = await newestFirst(storeDir, (await listDir(storeDir)).filter((f) => f.endsWith(".jsonl")));
+        const path = knownPaths.find((p) => storeDirName(p) === name) ??
+            (await sessionCwd(storeDir, sessions)) ??
+            null;
+        if (!path)
+            continue;
+        const store = await readMemoryStore(join(storeDir, "memory"), path);
+        byPath.set(path, {
+            path,
+            store,
+            exists: await isDir(path),
+            sessions: sessions.length,
+            lastActive: sessions[0] ? new Date(sessions[0].mtime).toISOString() : null,
+            memories: store?.memories.length ?? 0,
+            ephemeral: isEphemeral(env, path),
+        });
+    }
+    for (const path of [...knownPaths, resolve(launchDir)]) {
+        if (byPath.has(path))
+            continue;
+        byPath.set(path, {
+            path,
+            store: null,
+            exists: await isDir(path),
+            sessions: 0,
+            lastActive: null,
+            memories: 0,
+            ephemeral: isEphemeral(env, path),
+        });
+    }
+    return [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+function isEphemeral(env, path) {
+    return (path.startsWith("/tmp/") ||
+        path === "/tmp" ||
+        path.startsWith("/run/") ||
+        path.startsWith("/private/var/folders/") ||
+        path.startsWith("/var/folders/") ||
+        path.startsWith("/private/tmp/") ||
+        /[\\/]AppData[\\/]Local[\\/]Temp[\\/]/i.test(path) ||
+        path.startsWith(join(env.home, ".config", "Claude", "scratch-workspaces")));
+}
+/** Transcripts by last change, newest first; stat calls run in batches rather than one by one. */
+async function newestFirst(dir, files) {
+    const out = [];
+    for (let i = 0; i < files.length; i += 64) {
+        const batch = await Promise.all(files.slice(i, i + 64).map(async (file) => {
+            const info = await stat(join(dir, file)).catch(() => null);
+            return info ? { file, mtime: info.mtimeMs } : null;
+        }));
+        out.push(...batch.filter((t) => t !== null));
+    }
+    return out.sort((a, b) => b.mtime - a.mtime);
+}
+/** The `cwd` recorded in the newest transcripts, for store names that do not map back cleanly. */
+async function sessionCwd(storeDir, sessions) {
+    for (const { file } of sessions.slice(0, 3)) {
+        if (await leadsToSecret(join(storeDir, file)))
+            continue;
+        const input = createReadStream(join(storeDir, file), { encoding: "utf8" });
+        const lines = createInterface({ input });
+        let read = 0;
+        try {
+            for await (const line of lines) {
+                if (++read > 50)
+                    break;
+                if (!line.includes('"cwd"'))
+                    continue;
+                const parsed = JSON.parse(line);
+                if (isRecord(parsed) && typeof parsed.cwd === "string")
+                    return parsed.cwd;
+            }
+        }
+        catch {
+            // A truncated or malformed transcript line: try the next file.
+        }
+        finally {
+            lines.close();
+            input.destroy();
+        }
+    }
+    return null;
+}

package/dist/server/scan/settings.js

@@ -0,0 +1,317 @@
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { allowedScopes, ignoredReason } from "../../shared/scopes.js";
+import {} from "../../shared/types.js";
+import {} from "./env.js";
+import { isRecord, listDir, mainWorktreeRoot, readJsonObject, redactSecrets } from "./files.js";
+/** Lowest precedence first, so later layers override earlier ones. */
+const PRECEDENCE = ["user", "project", "local", "managed"];
+/** Keys whose whole value comes from the highest layer that sets it, even though they are lists. */
+const WHOLE_VALUE_KEYS = new Set(["fallbackModel", "modelPicker"]);
+/** Maps whose entries are taken whole from the highest layer that has them, never field by field. */
+const WHOLE_ENTRY_KEYS = new Set(["managedMcpServers", "extraKnownMarketplaces", "modelSettings"]);
+const ANY_FILE = ["user", "project", "local", "managed"];
+/**
+ * Keys, some nested, where Claude Code honours the more restrictive value from some files even over
+ * a higher file (docs: settings#exceptions-to-managed-settings-precedence).
+ */
+const STRICTEST = {
+    disableClaudeAiConnectors: { ladder: [false, true], from: ANY_FILE },
+    isolatePeerMachines: { ladder: [false, true], from: ANY_FILE },
+    enableArtifact: { ladder: [true, false], from: ANY_FILE },
+    disableArtifact: { ladder: [false, true], from: ANY_FILE },
+    "permissions.blockReadsOutsideWorkingDirectories": { ladder: [false, true], from: ANY_FILE },
+    "autoMode.classifyAllShell": { ladder: [false, true], from: ["user"] },
+    maxEffortLevel: { ladder: ["max", "xhigh", "high", "medium", "low"], from: ANY_FILE },
+    useAutoModeDuringPlan: { ladder: [true, false], from: ["managed", "user", "local"] },
+    syncClaudeAiSkills: { ladder: [true, false], from: ["managed", "user", "local"] },
+    syncClaudeAiPlugins: { ladder: [true, false], from: ["managed", "user", "local"] },
+    remoteControlAtStartup: { ladder: [true, false], from: ["project", "local"], onlyTightens: true },
+    crossSessionInbound: {
+        ladder: ["accept", "hold", "refuse"],
+        from: ["project", "local"],
+        onlyTightens: true,
+    },
+};
+/**
+ * Why Claude Code ignores a `permissions.defaultMode` from this file, or undefined when it may apply:
+ * a repository's settings cannot start sessions in auto or bypass mode (docs: permission-modes).
+ */
+export function ignoredModeReason(scope, mode) {
+    if ((scope === "project" || scope === "local") &&
+        (mode === "auto" || mode === "bypassPermissions"))
+        return `${mode} takes effect only from user or managed settings`;
+    return undefined;
+}
+/** A file's value for `key` without nested fields Claude Code ignores from that file, and what was dropped. */
+function withoutIgnoredFields(key, scope, value) {
+    if (key !== "permissions" || !isRecord(value))
+        return { value };
+    const reason = ignoredModeReason(scope, value.defaultMode);
+    if (!reason)
+        return { value };
+    const { defaultMode, ...rest } = value;
+    return { value: rest, dropped: { value: { defaultMode }, reason } };
+}
+/**
+ * The value that wins for a key with a strictness exception, given its values lowest precedence
+ * first; undefined when plain precedence decides.
+ */
+function strictWinner(strict, values) {
+    const rank = (value) => strict.ladder.indexOf(value);
+    const honoured = values.filter((v) => strict.from.includes(v.scope) && rank(v.value) >= 0);
+    const strictest = honoured.reduce((best, v) => (!best || rank(v.value) > rank(best.value) ? v : best), undefined);
+    const top = strict.onlyTightens
+        ? values.filter((v) => !strict.from.includes(v.scope)).at(-1)
+        : values.at(-1);
+    const baseline = top ? rank(top.value) : 0;
+    if (strictest && rank(strictest.value) > baseline)
+        return { winner: strictest };
+    if (strict.onlyTightens && honoured.length > 0)
+        return { winner: top ?? null };
+    return undefined;
+}
+function strictNote(strict) {
+    const files = strict.from.length === 4 ? "any" : strict.from.join(" or ");
+    return strict.onlyTightens
+        ? `Claude Code takes this key from ${files} settings only when it is stricter`
+        : `Claude Code keeps the strictest value of this key, from ${files} settings`;
+}
+/** Combines one key's values from two layers, `over` being the higher one. */
+function mergeKey(key, base, over) {
+    if (WHOLE_VALUE_KEYS.has(key))
+        return over;
+    if (WHOLE_ENTRY_KEYS.has(key) && isRecord(base) && isRecord(over))
+        return { ...base, ...over };
+    return deepMerge(base, over);
+}
+/** Combines two whole settings files, `over` being the higher one. */
+function mergeSettings(base, over) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(over))
+        out[key] = key in out ? mergeKey(key, out[key], value) : value;
+    return out;
+}
+/**
+ * Where Claude Code keeps `.claude/settings.local.json` for a session started in `dir`: the
+ * repository root (the main checkout's root in a worktree), except outside git, when that root is
+ * the home directory, on Windows, or when the root, its .git or its .claude is not yours
+ * (docs: settings#where-claude-code-looks-for-each-file).
+ */
+async function localSettingsDir(env, dir) {
+    if (env.platform === "win32")
+        return dir;
+    const root = await mainWorktreeRoot(dir);
+    if (!root || root === env.home)
+        return dir;
+    const uid = process.getuid?.();
+    for (const path of [root, join(root, ".git"), join(root, ".claude")]) {
+        const info = await lstat(path).catch(() => null);
+        if (info && uid !== undefined && info.uid !== uid)
+            return dir;
+    }
+    return root;
+}
+/** The settings files Claude Code reads in `dir`, highest precedence first. */
+export async function settingsFiles(env, dir) {
+    const localDir = await localSettingsDir(env, dir);
+    const userFile = join(env.claudeDir, "settings.json");
+    const files = [
+        { scope: "managed", path: join(env.managedDir, "managed-settings.json") },
+        { scope: "local", path: join(localDir, ".claude", "settings.local.json") },
+    ];
+    // Before v2.1.211 the local file lived in the start directory; Claude Code still reads one left there.
+    if (localDir !== dir)
+        files.push({ scope: "local", path: join(dir, ".claude", "settings.local.json"), legacy: true });
+    const projectFile = join(dir, ".claude", "settings.json");
+    // In the home directory, .claude/settings.json is the user file, not a project layer.
+    if (projectFile !== userFile)
+        files.push({ scope: "project", path: projectFile });
+    files.push({ scope: "user", path: userFile });
+    return files;
+}
+/** Settings files that apply in `dir`, highest precedence first. */
+export async function readSettingsLayers(env, dir) {
+    const layers = [];
+    for (const file of await settingsFiles(env, dir)) {
+        if (file.scope === "managed") {
+            layers.push(await readManagedLayer(env, file.path));
+            continue;
+        }
+        const result = await readJsonObject(file.path);
+        if (file.legacy && !result.ok && result.missing)
+            continue;
+        const layer = { scope: file.scope, path: file.path, exists: true, data: null };
+        if (file.legacy)
+            layer.legacy = true;
+        if (result.ok)
+            layer.data = redactSecrets(result.data);
+        else if (result.missing)
+            layer.exists = false;
+        else
+            layer.error = result.error;
+        layers.push(layer);
+    }
+    return layers;
+}
+/**
+ * managed-settings.json, then every *.json in managed-settings.d in alphabetical order, merged, with
+ * nothing hidden: for checks such as managedMcpServers that must see header values. Never sent to the
+ * page as is.
+ */
+export async function readManagedSettings(env) {
+    const dropInDir = join(env.managedDir, "managed-settings.d");
+    const dropIns = (await listDir(dropInDir))
+        .filter((name) => name.endsWith(".json") && !name.startsWith("."))
+        .map((name) => join(dropInDir, name));
+    const sources = [];
+    const errors = [];
+    let data = null;
+    for (const source of [join(env.managedDir, "managed-settings.json"), ...dropIns]) {
+        const result = await readJsonObject(source);
+        if (!result.ok) {
+            if (!result.missing)
+                errors.push(`${source}: ${result.error}`);
+            continue;
+        }
+        sources.push(source);
+        data = data ? mergeSettings(data, result.data) : result.data;
+    }
+    return { data, sources, dropIns, errors };
+}
+async function readManagedLayer(env, path) {
+    const { data, sources, dropIns, errors } = await readManagedSettings(env);
+    const layer = { scope: "managed", path, exists: false, data: null };
+    if (data)
+        layer.data = redactSecrets(data);
+    layer.exists = sources.length > 0 || errors.length > 0;
+    if (sources.length > 1 || dropIns.length > 0)
+        layer.sources = sources;
+    if (errors.length > 0)
+        layer.error = errors.join("; ");
+    return layer;
+}
+/** The value Claude Code ends up with for each top-level key, and where it came from. */
+export function effectiveSettings(layers) {
+    // Layers are highest first; a second layer of one scope (a legacy local file) sits under the first.
+    const byScope = new Map();
+    for (const layer of layers) {
+        if (!layer.data)
+            continue;
+        const higher = byScope.get(layer.scope);
+        byScope.set(layer.scope, higher ? mergeSettings(layer.data, higher) : layer.data);
+    }
+    const keys = new Set([...byScope.values()].flatMap((data) => Object.keys(data)));
+    const out = [];
+    for (const key of [...keys].sort()) {
+        const allowed = allowedScopes(key);
+        const present = PRECEDENCE.filter((scope) => byScope.get(scope)?.[key] !== undefined);
+        const valueIn = (scope) => byScope.get(scope)?.[key];
+        const ignored = present
+            .filter((scope) => !allowed.includes(scope))
+            .map((scope) => ({ scope, value: valueIn(scope), reason: ignoredReason(key) }));
+        let defined = present.filter((scope) => allowed.includes(scope));
+        // A managed availableModels list is applied as-is; other files' entries are ignored.
+        if (key === "availableModels" && defined.includes("managed")) {
+            for (const scope of defined.filter((s) => s !== "managed"))
+                ignored.push({
+                    scope,
+                    value: valueIn(scope),
+                    reason: "Managed settings set availableModels, so Claude Code uses that list as-is",
+                });
+            defined = ["managed"];
+        }
+        if (defined.length === 0) {
+            out.push({ key, value: undefined, from: [], merged: false, overridden: [], ignored });
+            continue;
+        }
+        const values = defined.map((scope) => {
+            const { value, dropped } = withoutIgnoredFields(key, scope, valueIn(scope));
+            if (dropped)
+                ignored.push({ scope, ...dropped });
+            return { scope, value };
+        });
+        const top = values[values.length - 1];
+        if (!top)
+            continue;
+        const mergeable = !WHOLE_VALUE_KEYS.has(key) &&
+            values.every((v) => Array.isArray(v.value) || isRecord(v.value));
+        const strict = STRICTEST[key];
+        const decided = strict && strictWinner(strict, values);
+        if (strict && decided) {
+            const { winner } = decided;
+            out.push({
+                key,
+                value: winner?.value,
+                from: winner ? [winner.scope] : [],
+                merged: false,
+                overridden: values.filter((v) => v !== winner).reverse(),
+                ignored,
+                note: strictNote(strict),
+            });
+        }
+        else if (mergeable && values.length > 1) {
+            out.push({
+                key,
+                value: withStrictFields(key, values.slice(1).reduce((acc, v) => mergeKey(key, acc, v.value), values[0]?.value), values),
+                from: defined,
+                merged: true,
+                overridden: [],
+                ignored,
+            });
+        }
+        else if (isRecord(top.value)) {
+            out.push({
+                key,
+                value: withStrictFields(key, top.value, values),
+                from: [top.scope],
+                merged: false,
+                overridden: values.slice(0, -1).reverse(),
+                ignored,
+            });
+        }
+        else {
+            out.push({
+                key,
+                value: top.value,
+                from: [top.scope],
+                merged: false,
+                overridden: values.slice(0, -1).reverse(),
+                ignored,
+            });
+        }
+    }
+    return out;
+}
+/** An object setting with each nested strictness exception (such as permissions.x) applied. */
+function withStrictFields(key, value, values) {
+    if (!isRecord(value))
+        return value;
+    let out = value;
+    for (const [path, strict] of Object.entries(STRICTEST)) {
+        const [head, field] = path.split(".");
+        if (head !== key || !field)
+            continue;
+        const fieldValues = values
+            .filter((v) => isRecord(v.value) && v.value[field] !== undefined)
+            .map((v) => ({ scope: v.scope, value: v.value[field] }));
+        const decided = strictWinner(strict, fieldValues);
+        if (decided)
+            out = { ...out, [field]: decided.winner?.value };
+    }
+    return out;
+}
+/** Objects merge by key, lists concatenate without duplicates, anything else is replaced. */
+function deepMerge(base, over) {
+    if (Array.isArray(base) && Array.isArray(over)) {
+        const seen = new Set(base.map((v) => JSON.stringify(v)));
+        return [...base, ...over.filter((v) => !seen.has(JSON.stringify(v)))];
+    }
+    if (isRecord(base) && isRecord(over)) {
+        const out = { ...base };
+        for (const [k, v] of Object.entries(over))
+            out[k] = k in out ? deepMerge(out[k], v) : v;
+        return out;
+    }
+    return over;
+}

package/dist/server/scan/tools.js

@@ -0,0 +1,107 @@
+import table from "../../shared/builtin-tools.json" with { type: "json" };
+import {} from "../../shared/types.js";
+import { wildcard } from "./files.js";
+/**
+ * The other tools a rule for some uses covers: Bash rules apply to Monitor, Claude Code checks file
+ * paths against Edit and Read rules only, and a Read deny also blocks Edit and Write on that path
+ * (docs: tools-reference#configure-tools-with-permission-rules-and-hooks, permissions#read-and-edit).
+ */
+function coveredTools(tool, list) {
+    if (tool === "Bash")
+        return ["Bash", "Monitor"];
+    if (tool === "Edit")
+        return ["Edit", "Write", "NotebookEdit"];
+    if (tool === "Read")
+        return list === "deny"
+            ? ["Read", "Grep", "Glob", "LSP", "Edit", "Write"]
+            : ["Read", "Grep", "Glob", "LSP"];
+    return [];
+}
+/** Path rules Claude Code accepts but never consults; Edit and Read rules do the job instead. */
+const UNCHECKED_PATH_RULE_TOOLS = new Set(["Write", "NotebookEdit", "Glob", "MultiEdit"]);
+/**
+ * No deny or ask rule and no PreToolUse hook applies to it while any other tool remains
+ * (docs: tools-reference#endconversation-tool-behavior).
+ */
+const EXEMPT = "EndConversation";
+/** `Tool` or `Tool(specifier)`; `Tool(*)` names the whole tool too (docs: permissions#permission-rule-syntax). */
+export function parseRule(rule) {
+    const open = rule.indexOf("(");
+    if (open === -1 || !rule.endsWith(")"))
+        return { tool: rule.trim(), specifier: null };
+    const specifier = rule.slice(open + 1, -1);
+    return { tool: rule.slice(0, open).trim(), specifier: specifier === "*" ? null : specifier };
+}
+/** Deny and ask rules may glob the tool name; allow rules name it exactly (docs: permissions#tool-name-wildcards). */
+export function namesTool(list, tool, name) {
+    return list === "allow" || !tool.includes("*") ? tool === name : wildcard(tool).test(name);
+}
+/** A hook matcher, evaluated as the docs describe (docs: hooks#matcher-patterns). */
+function matcherCovers(matcher, name) {
+    if (matcher === undefined || matcher === "" || matcher === "*")
+        return true;
+    if (/^[\w\s,|-]+$/.test(matcher))
+        return matcher.split(/[|,]/).some((part) => part.trim() === name);
+    try {
+        return new RegExp(matcher).test(name);
+    }
+    catch {
+        return false;
+    }
+}
+const ORDER = ["deny", "ask", "allow"];
+/** Every built-in tool, with the rules and hooks that apply to it here. */
+export function builtinTools(permissions, hooks) {
+    const rules = permissions.flatMap((p) => p.kind === "rule" && p.inEffect ? [{ list: p.list, rule: p.rule, scope: p.scope }] : []);
+    const preToolUse = hooks.filter((h) => h.active && h.event === "PreToolUse");
+    const tools = table.tools.map(({ name, description, asks }) => {
+        const whole = [];
+        const scoped = [];
+        for (const r of rules) {
+            if (name === EXEMPT)
+                break;
+            const { tool, specifier } = parseRule(r.rule);
+            if (specifier === null) {
+                if (namesTool(r.list, tool, name))
+                    whole.push(r);
+            }
+            else if (tool === name && UNCHECKED_PATH_RULE_TOOLS.has(tool)) {
+                scoped.push({ ...r, unchecked: true });
+            }
+            else if (tool === name || coveredTools(tool, r.list).includes(name))
+                scoped.push(r);
+        }
+        const decidedBy = ORDER.map((list) => whole.find((r) => r.list === list)).find(Boolean);
+        const tool = {
+            name,
+            description,
+            asks,
+            verdict: decidedBy
+                ? { deny: "denied", ask: "asks", allow: "allowed" }[decidedBy.list]
+                : "default",
+            scoped: scoped.sort((a, b) => ORDER.indexOf(a.list) - ORDER.indexOf(b.list)),
+            hooks: name === EXEMPT ? 0 : preToolUse.filter((h) => matcherCovers(h.matcher, name)).length,
+        };
+        if (decidedBy)
+            tool.decidedBy = decidedBy;
+        const removedBy = whole.filter((r) => r.list === "deny");
+        if (removedBy.length > 0)
+            tool.removedBy = removedBy;
+        return tool;
+    });
+    // EndConversation ignores rules while any other tool remains. When deny rules remove every other
+    // tool and match it too, as "*" does, it goes as well, unless an allow rule names it.
+    const exempt = tools.find((t) => t.name === EXEMPT);
+    const othersGone = tools.every((t) => t.name === EXEMPT || t.verdict === "denied");
+    const denies = rules.filter((r) => {
+        const { tool, specifier } = parseRule(r.rule);
+        return r.list === "deny" && specifier === null && namesTool("deny", tool, EXEMPT);
+    });
+    const kept = rules.some((r) => r.list === "allow" && r.rule === EXEMPT);
+    if (exempt && othersGone && denies[0] && !kept) {
+        exempt.verdict = "denied";
+        exempt.decidedBy = denies[0];
+        exempt.removedBy = denies;
+    }
+    return tools;
+}