ccdesk 0.0.0-stage → 0.2.0

package/dist/server/scan/plugins.js

@@ -0,0 +1,124 @@
+import { join, resolve } from "node:path";
+import { HIGHEST_FIRST } from "../../shared/scopes.js";
+import {} from "../../shared/types.js";
+import {} from "./env.js";
+import { isRecord, isWithin, readJsonObject, resolvedPath, stringField } from "./files.js";
+function manifestPath(plugin) {
+    return join(plugin.installPath, ".claude-plugin", "plugin.json");
+}
+async function manifest(env, plugin) {
+    const result = await readJsonObject(env, manifestPath(plugin));
+    return result.ok ? result.data : {};
+}
+/**
+ * The prefix of a plugin's skills, commands and agents: the manifest's name, which wins over the
+ * name the plugin is enabled under (docs: plugins-reference#name, #metadata-precedence).
+ */
+export async function pluginNamespace(env, plugin) {
+    return stringField(await manifest(env, plugin), "name") || (plugin.id.split("@")[0] ?? plugin.id);
+}
+/** Installed plugins that apply in `projectDir`, with whether each is enabled and by which file. */
+export async function readPlugins(env, layers, projectDir, gitRoot) {
+    const installed = await readJsonObject(env, join(env.claudeDir, "plugins", "installed_plugins.json"));
+    if (!installed.ok || !isRecord(installed.data.plugins))
+        return [];
+    const out = [];
+    for (const [id, installs] of Object.entries(installed.data.plugins)) {
+        if (!Array.isArray(installs))
+            continue;
+        // A project or local install applies only in its own project; it beats a user install there.
+        const records = installs.filter((i) => isRecord(i));
+        const install = records.find((i) => i.projectPath === projectDir || (gitRoot && i.projectPath === gitRoot)) ??
+            records.find((i) => typeof i.projectPath !== "string");
+        if (!install)
+            continue;
+        const plugin = {
+            id,
+            version: stringField(install, "version"),
+            scope: stringField(install, "scope"),
+            installPath: stringField(install, "installPath"),
+            updated: stringField(install, "lastUpdated") || null,
+            enabled: true,
+            note: "",
+        };
+        const setting = HIGHEST_FIRST.flatMap((scope) => layers
+            .filter((l) => l.scope === scope)
+            .map((l) => l.data?.enabledPlugins)
+            .filter(isRecord)
+            .filter((flags) => flags[id] !== undefined)
+            .map((flags) => ({ scope, value: flags[id] })))[0];
+        if (setting) {
+            plugin.enabled = setting.value !== false;
+            plugin.enabledIn = setting.scope;
+            plugin.note = `${plugin.enabled ? "Enabled" : "Turned off"} in ${setting.scope} settings`;
+        }
+        else {
+            plugin.enabled = (await manifest(env, plugin)).defaultEnabled !== false;
+            plugin.note = plugin.enabled
+                ? "On by default (no enabledPlugins entry)"
+                : "Off by default (no enabledPlugins entry)";
+        }
+        out.push(plugin);
+    }
+    return out;
+}
+/** A path from a manifest, if it stays inside the plugin once links are followed. */
+async function inside(plugin, path) {
+    const target = resolve(plugin.installPath, path);
+    const root = await resolvedPath(plugin.installPath);
+    return isWithin(root, await resolvedPath(target)) ? target : null;
+}
+/** The paths a manifest key names (one path or a list), inside the plugin; null when unset. */
+export async function manifestPaths(env, plugin, key) {
+    const value = (await manifest(env, plugin))[key];
+    const list = typeof value === "string" ? [value] : Array.isArray(value) ? value : null;
+    if (!list)
+        return null;
+    const out = [];
+    for (const item of list) {
+        if (typeof item !== "string")
+            continue;
+        const path = await inside(plugin, item);
+        if (path)
+            out.push(path);
+    }
+    return out;
+}
+/** The value of a manifest key that is a path, an inline object, or a list of either. */
+export async function manifestConfigs(env, plugin, key) {
+    const value = (await manifest(env, plugin))[key];
+    const out = [];
+    for (const item of Array.isArray(value) ? value : value === undefined ? [] : [value]) {
+        if (isRecord(item))
+            out.push({ value: item, path: manifestPath(plugin) });
+        if (typeof item !== "string")
+            continue;
+        const path = await inside(plugin, item);
+        const file = path ? await readJsonObject(env, path) : null;
+        if (path && file?.ok)
+            out.push({ value: file.data[key] ?? file.data, path });
+    }
+    return out;
+}
+/** The manifest's `commands` object form: command name to a file or inline content. */
+export async function manifestCommandMap(env, plugin) {
+    const value = (await manifest(env, plugin)).commands;
+    if (!isRecord(value))
+        return [];
+    const out = [];
+    for (const [name, entry] of Object.entries(value)) {
+        if (!isRecord(entry))
+            continue;
+        const source = typeof entry.source === "string" ? await inside(plugin, entry.source) : null;
+        const content = typeof entry.content === "string" ? entry.content : null;
+        if (!source && content === null)
+            continue;
+        out.push({
+            name,
+            path: source ?? manifestPath(plugin),
+            description: stringField(entry, "description"),
+            text: content,
+        });
+    }
+    return out;
+}

package/dist/server/scan/projects.js

@@ -0,0 +1,101 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { storeDirName } from "../../shared/memory.js";
+import {} from "../../shared/types.js";
+import {} from "./env.js";
+import { isCredentials, isDir, isRecord, listDir } from "./files.js";
+import { readMemoryStore } 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(env, storeDir, sessions)) ??
+            null;
+        if (!path)
+            continue;
+        const store = await readMemoryStore(env, 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(env, storeDir, sessions) {
+    for (const { file } of sessions.slice(0, 3)) {
+        if (await isCredentials(env, 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/sandbox.js

@@ -0,0 +1,161 @@
+import {} from "../../shared/types.js";
+import { isRecord, stringsIn } from "./files.js";
+const REPOSITORY = ["project", "local"];
+const NOT_MANAGED = ["user", "project", "local"];
+function at(value, path) {
+    return path.reduce((o, k) => (isRecord(o) ? o[k] : undefined), value);
+}
+function nested(path, leaf) {
+    return path.reduceRight((acc, k) => ({ [k]: acc }), leaf);
+}
+/**
+ * `value` with the field at `path` set to `leaf`, or removed when `leaf` is undefined, along with
+ * any object that removal leaves empty.
+ */
+function replaced(value, path, leaf) {
+    const [head, ...rest] = path;
+    if (head === undefined)
+        return value;
+    const out = { ...value };
+    const child = out[head];
+    if (rest.length > 0 && !isRecord(child))
+        return value;
+    const next = isRecord(child) && rest.length > 0 ? replaced(child, rest, leaf) : leaf;
+    if (next === undefined || (isRecord(next) && Object.keys(next).length === 0))
+        delete out[head];
+    else
+        out[head] = next;
+    return out;
+}
+/**
+ * Which `sandbox` fields Claude Code ignores from which files, given every file's `sandbox` and
+ * `permissions` values (docs: settings-reference#sandbox-settings, sandboxing#keep-developers-from-widening-the-policy).
+ * Locks that depend on paths, such as allowRead entries under a path that managed settings deny
+ * reading, and anything the --settings flag sets, are not modelled.
+ */
+function rulesFor(valueIn) {
+    const managed = valueIn("sandbox", "managed");
+    const user = valueIn("sandbox", "user");
+    const managedSays = (path, value) => at(managed, path.split(".")) === value;
+    const rules = [];
+    const add = (fields, from, reason, drops) => {
+        for (const field of fields)
+            rules.push({ field, from, reason, ...(drops ? { drops } : {}) });
+    };
+    // Keys read from fewer files (docs: settings-reference, each key's Scope).
+    for (const field of [
+        "filesystem.allowManagedReadPathsOnly",
+        "network.allowManagedDomainsOnly",
+        "bwrapPath",
+        "socatPath",
+    ])
+        add([field], NOT_MANAGED, `Claude Code reads sandbox.${field} only from managed settings`);
+    for (const field of [
+        "allowAppleEvents",
+        "ripgrep",
+        "credentials.allowPlaintextInject",
+        "credentials.awsPairs",
+        "credentials.sigv4",
+        "network.strictAllowlist",
+        "network.tlsTerminate",
+    ])
+        add([field], REPOSITORY, `Claude Code reads sandbox.${field} only from user or managed settings`);
+    // docs: sandboxing#which-settings-can-disable-it
+    const managedFiles = at(managed, ["credentials", "files"]);
+    const filesystemLocked = isRecord(at(managed, ["filesystem"])) ||
+        (Array.isArray(managedFiles) && managedFiles.some((f) => isRecord(f) && f.mode === "deny"));
+    add(["filesystem.disabled"], filesystemLocked ? NOT_MANAGED : REPOSITORY, filesystemLocked
+        ? "Managed settings configure the sandbox filesystem, so only they can turn it off"
+        : "Claude Code reads sandbox.filesystem.disabled only from user or managed settings");
+    add(["credentials.files", "credentials.envVars"], REPOSITORY, "Claude Code drops mask entries from repository settings", { entries: (e) => isRecord(e) && e.mode === "mask" });
+    // docs: sandboxing#turn-off-the-retry-with-strict-sandbox-mode
+    if (managedSays("allowUnsandboxedCommands", false) ||
+        at(user, ["allowUnsandboxedCommands"]) === false)
+        add(["allowUnsandboxedCommands"], REPOSITORY, "A false in user or managed settings holds against a repository's true", { value: true });
+    // Managed-only locks (docs: sandboxing#keep-developers-from-widening-the-policy).
+    if (managedSays("filesystem.allowManagedReadPathsOnly", true))
+        add(["filesystem.allowRead"], NOT_MANAGED, "Managed settings honor only their own allowRead entries (allowManagedReadPathsOnly)");
+    const domainsLocked = managedSays("network.allowManagedDomainsOnly", true);
+    if (domainsLocked)
+        add(["network.allowedDomains", "network.httpProxyPort", "network.socksProxyPort"], NOT_MANAGED, "Managed settings honor only their own domains and proxy ports (allowManagedDomainsOnly)");
+    // docs: sandboxing#repository-settings-under-an-admin-required-sandbox
+    if (managedSays("allowUnsandboxedCommands", false) || domainsLocked) {
+        const reason = "Managed settings require the sandbox, so Claude Code ignores repository settings that loosen it";
+        add([
+            "excludedCommands",
+            "ignoreViolations",
+            "network.allowedDomains",
+            "network.allowUnixSockets",
+            "network.allowMachLookup",
+            "network.httpProxyPort",
+            "network.socksProxyPort",
+            "filesystem.allowWrite",
+        ], REPOSITORY, reason);
+        add([
+            "enableWeakerNestedSandbox",
+            "enableWeakerNetworkIsolation",
+            "network.allowAllUnixSockets",
+            "network.allowLocalBinding",
+        ], REPOSITORY, reason, { value: true });
+        for (const field of ["enabled", "failIfUnavailable"])
+            if (at(user, [field]) === true)
+                add([field], REPOSITORY, reason, { value: false });
+    }
+    // docs: sandboxing#locks-that-apply-without-an-admin-required-sandbox
+    const managedDeny = stringsIn(at(valueIn("permissions", "managed"), ["deny"]));
+    if (stringsIn(at(managed, ["network", "deniedDomains"])).length > 0 ||
+        managedDeny.some((rule) => rule.startsWith("WebFetch(domain:")))
+        add(["network.httpProxyPort", "network.socksProxyPort"], REPOSITORY, "Managed settings deny domains, so a repository cannot set a proxy port");
+    const strictAllowlist = at(managed, ["network", "strictAllowlist"]) ?? at(user, ["network", "strictAllowlist"]);
+    if (strictAllowlist === true)
+        add(["network.allowedDomains", "network.httpProxyPort", "network.socksProxyPort"], REPOSITORY, "strictAllowlist is on, so Claude Code ignores a repository's domains and proxy ports");
+    // While the block covers sandboxed commands, repository allowRead and allowWrite entries do not
+    // count; it does not when filesystem isolation is off or allowManagedReadPathsOnly is set
+    // (docs: settings-reference#sandboxed-commands-under-the-block).
+    const blocked = ["user", "project", "local", "managed"].some((s) => at(valueIn("permissions", s), ["blockReadsOutsideWorkingDirectories"]) === true);
+    const filesystemOff = (filesystemLocked ? [managed] : [managed, user])
+        .map((v) => at(v, ["filesystem", "disabled"]))
+        .find((v) => v !== undefined) === true;
+    if (blocked && !filesystemOff && !managedSays("filesystem.allowManagedReadPathsOnly", true))
+        add(["filesystem.allowRead", "filesystem.allowWrite"], REPOSITORY, "blockReadsOutsideWorkingDirectories is on, so repository allowRead and allowWrite entries do not count");
+    return rules;
+}
+/**
+ * A filter for each file's `sandbox` value: what is left once the fields Claude Code ignores from
+ * that file are taken out, and what was taken out.
+ */
+export function sandboxFilter(valueIn) {
+    const rules = rulesFor(valueIn);
+    return (scope, value) => {
+        if (!isRecord(value))
+            return { value, dropped: [] };
+        let out = value;
+        const dropped = [];
+        for (const rule of rules) {
+            if (!rule.from.includes(scope))
+                continue;
+            const path = rule.field.split(".");
+            const field = at(out, path);
+            if (field === undefined)
+                continue;
+            const drops = rule.drops;
+            let removed = field;
+            let kept;
+            if (drops && "value" in drops) {
+                if (field !== drops.value)
+                    continue;
+            }
+            else if (drops) {
+                if (!Array.isArray(field))
+                    continue;
+                removed = field.filter(drops.entries);
+                if (removed.length === 0)
+                    continue;
+                kept = field.filter((e) => !drops.entries(e));
+            }
+            out = replaced(out, path, kept);
+            dropped.push({ value: nested(path, removed), reason: rule.reason });
+        }
+        return { value: out, dropped };
+    };
+}