ccdesk 0.2.2 → 0.2.3

package/dist/server/scan/files.js

@@ -1,480 +0,0 @@
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import {} from "node:fs";
-import { lstat, open, readdir, readlink, realpath, stat } from "node:fs/promises";
-import { basename, dirname, join, normalize, relative, resolve, sep } from "node:path";
-import { promisify } from "node:util";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import {} from "../../shared/types.js";
-import {} from "./env.js";
-const run = promisify(execFile);
-/** Claude Code skips a CLAUDE.md larger than this (docs: memory#auto-memory), so ccdesk reads no more. */
-export const MAX_TEXT_BYTES = 4 * 1024 * 1024;
-/** ccdesk never reads Claude Code's credentials, whatever name or link leads to them. */
-export function isSecretPath(path) {
-    return basename(path) === ".credentials.json";
-}
-/**
- * Whether a path, any link on the way, or the file it finally leads to is the credentials file, so
- * a credentials file that is itself a link is caught too. Checked before opening.
- */
-async function leadsToSecret(path) {
-    let current = path;
-    for (let hop = 0; hop < 40; hop++) {
-        if (isSecretPath(current))
-            return true;
-        const info = await lstat(current).catch(() => null);
-        if (!info?.isSymbolicLink())
-            break;
-        current = resolve(dirname(current), await readlink(current));
-    }
-    return isSecretPath(await realpath(path).catch(() => path));
-}
-/** The identity of `<config>/.credentials.json`, or null when there is none. */
-function credentialsIdentity(env) {
-    return stat(join(env.claudeDir, ".credentials.json"), { bigint: true }).catch(() => null);
-}
-function sameFile(a, b) {
-    return b !== null && a.dev === b.dev && a.ino === b.ino;
-}
-/**
- * Whether a path is Claude Code's credentials file: by name, through any link on the way, or by
- * being the same file as `<config>/.credentials.json`, so a copy kept under another name or a hard
- * link to it counts too.
- */
-export async function isCredentials(env, path) {
-    if (await leadsToSecret(path))
-        return true;
-    const info = await stat(path, { bigint: true }).catch(() => null);
-    return info !== null && sameFile(info, await credentialsIdentity(env));
-}
-/**
- * Opens a file to read, or null for the credentials file. The open file is checked again, so a
- * file swapped in after the first check is not read either.
- */
-async function openUnlessCredentials(env, path) {
-    if (await isCredentials(env, path))
-        return null;
-    const handle = await open(path, "r");
-    if (sameFile(await handle.stat({ bigint: true }), await credentialsIdentity(env))) {
-        await handle.close();
-        return null;
-    }
-    return handle;
-}
-/**
- * A JSON parse failure without the parser's message, which quotes the text around the fault and
- * so can quote a secret.
- */
-export function jsonSyntaxError(error) {
-    const at = /line (\d+) column (\d+)/.exec(String(error));
-    return at ? `not valid JSON (line ${at[1]}, column ${at[2]})` : "not valid JSON";
-}
-/**
- * The text ccdesk shows for a file reached as an instruction, import, memory, agent or skill. A
- * settings or MCP file read this way, whatever it is named, would otherwise show its env and
- * headers values, so anything that parses as JSON is shown parsed with them hidden. Frontmatter can
- * hold the same values, in a subagent's inline MCP servers (docs: sub-agents#scope-mcp-servers-to-a-subagent),
- * so frontmatter that holds any is shown re-written with them hidden.
- */
-export function shownText(text) {
-    if (text === null)
-        return null;
-    let data;
-    try {
-        data = JSON.parse(text);
-    }
-    catch {
-        return shownFrontmatter(text);
-    }
-    return typeof data === "object" && data !== null
-        ? `${JSON.stringify(redactSecrets(data), null, 2)}\n`
-        : text;
-}
-function shownFrontmatter(text) {
-    const match = FRONTMATTER.exec(text);
-    if (!match)
-        return text;
-    let data;
-    try {
-        data = parseYaml(match[1] ?? "");
-    }
-    catch {
-        return text;
-    }
-    const redacted = redactSecrets(data);
-    if (JSON.stringify(redacted) === JSON.stringify(data))
-        return text;
-    return `---\n${stringifyYaml(redacted)}---\n${text.slice(match[0].length)}`;
-}
-/** A file named .json that does not parse is not shown: its text could still hold a secret. */
-function shownJsonFile(text) {
-    try {
-        JSON.parse(text);
-    }
-    catch {
-        return "(a JSON file ccdesk could not parse, so its text is not shown; open it to see it)\n";
-    }
-    return shownText(text) ?? "";
-}
-/**
- * A UNC share or a path under /net or /Network. Claude Code does not follow a link there, because
- * looking it up can contact the host it names (docs: memory#share-rules-across-projects-with-symlinks).
- */
-export function isNetworkPath(path) {
-    if (/^[\\/]{2}wsl(\$|\.localhost)[\\/]/i.test(path))
-        return false;
-    return /^[\\/]{2}[^\\/]/.test(path) || /^\/(net|Network)(\/|$)/.test(path);
-}
-/** Where a symlink points, read without following it; null for anything else. */
-async function linkTarget(path) {
-    try {
-        if (!(await lstat(path)).isSymbolicLink())
-            return null;
-        return resolve(dirname(path), await readlink(path));
-    }
-    catch {
-        return null;
-    }
-}
-/** A link to a network location, which ccdesk, like Claude Code, does not follow. */
-async function linksToNetwork(path) {
-    const target = await linkTarget(path);
-    return target !== null && isNetworkPath(target);
-}
-/** A pattern where `*` matches anything, matched against the whole string. */
-export function wildcard(pattern, flags = "") {
-    const body = pattern
-        .split("*")
-        .map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
-        .join(".*");
-    return new RegExp(`^${body}$`, flags);
-}
-export function isWithin(parent, child) {
-    const rel = relative(parent, child);
-    // Only the parent segment leads out; a name such as ..cache is inside.
-    const up = rel === ".." || rel.startsWith(`..${sep}`);
-    return rel === "" || (!up && !rel.startsWith(sep) && !/^[a-zA-Z]:/.test(rel));
-}
-export async function isDir(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export async function isFile(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-export async function listDir(path) {
-    try {
-        return (await readdir(path)).sort();
-    }
-    catch {
-        return [];
-    }
-}
-export async function readTextFile(env, path) {
-    try {
-        if (await linksToNetwork(path))
-            return null;
-        const real = await realpath(path);
-        const info = await stat(path);
-        if (!info.isFile())
-            return null;
-        const handle = await openUnlessCredentials(env, path);
-        if (!handle)
-            return null;
-        let text;
-        try {
-            const buffer = Buffer.alloc(Math.min(info.size, MAX_TEXT_BYTES));
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-            text = buffer.subarray(0, bytesRead).toString("utf8");
-        }
-        finally {
-            await handle.close();
-        }
-        text = real.endsWith(".json") ? shownJsonFile(text) : (shownText(text) ?? "");
-        const ref = {
-            path,
-            mtime: info.mtime.toISOString(),
-            bytes: info.size,
-            lines: text === "" ? 0 : text.split("\n").length,
-            text,
-        };
-        if ((await lstat(path)).isSymbolicLink())
-            ref.realPath = real;
-        return ref;
-    }
-    catch {
-        return null;
-    }
-}
-export async function resolvedPath(path) {
-    try {
-        return await realpath(path);
-    }
-    catch {
-        return path;
-    }
-}
-/** A JSON object file; `emptyIsObject` reads an empty file as `{}`. */
-export async function readJsonObject(env, path, { emptyIsObject = false } = {}) {
-    let raw;
-    try {
-        const handle = await openUnlessCredentials(env, path);
-        if (!handle)
-            return { ok: false, missing: false, error: "ccdesk does not read credentials" };
-        try {
-            raw = await handle.readFile("utf8");
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    catch (error) {
-        const missing = error.code === "ENOENT";
-        return { ok: false, missing, error: String(error) };
-    }
-    if (emptyIsObject && raw.trim() === "")
-        return { ok: true, data: {} };
-    try {
-        const data = JSON.parse(raw);
-        if (!isRecord(data))
-            return { ok: false, missing: false, unparsed: true, error: "not a JSON object" };
-        return { ok: true, data };
-    }
-    catch (error) {
-        return { ok: false, missing: false, unparsed: true, error: jsonSyntaxError(error) };
-    }
-}
-export function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * A server URL as ccdesk shows it: a user name, password or query string can carry a key, so they
- * are hidden, as Claude Code hides the URL in its own status output (docs: mcp).
- */
-export function shownUrl(url) {
-    try {
-        const u = new URL(url);
-        if (!u.username && !u.password && !u.search)
-            return url;
-        if (u.username || u.password) {
-            u.username = "•••";
-            u.password = "";
-        }
-        if (u.search)
-            u.search = "?•••";
-        return decodeURI(u.toString());
-    }
-    catch {
-        return url.replace(/\/\/[^/@]*@/, "//•••@").replace(/\?.*$/, "?•••");
-    }
-}
-/** A flag whose value is a secret, such as `--token` or `--api-key`. */
-const SECRET_FLAG = /^--(token|api[-_]?key|apikey|password|secret|auth|key)$/i;
-/** A value that starts like a common API key or token. */
-const KEY_PREFIX = /^(sk-|ghp_|gho_|ghu_|ghs_|ghr_|github_pat_|xox[bp]-|glpat-|AKIA[0-9A-Z]{16})/;
-/**
- * A server's command-line arguments as ccdesk shows them: the value after a secret flag, given as
- * `--token value` or `--token=value`, a value that starts like a known key, and the credentials in
- * a URL are hidden.
- */
-export function shownArgs(args) {
-    return args.map((arg, i) => {
-        if (typeof arg !== "string")
-            return arg;
-        const previous = args[i - 1];
-        if (typeof previous === "string" && SECRET_FLAG.test(previous) && !arg.startsWith("-"))
-            return "•••";
-        const equals = arg.indexOf("=");
-        if (equals > 0) {
-            const name = arg.slice(0, equals);
-            if (SECRET_FLAG.test(name) || KEY_PREFIX.test(arg.slice(equals + 1)))
-                return `${name}=•••`;
-        }
-        if (KEY_PREFIX.test(arg))
-            return "•••";
-        if (/^https?:\/\//i.test(arg))
-            return shownUrl(arg);
-        return arg;
-    });
-}
-/**
- * Replace values that commonly hold secrets with a placeholder, keeping the keys: env and headers
- * values, the user, password and query of a `url`, and secret values in the `args` of a command.
- */
-export function redactSecrets(value) {
-    if (Array.isArray(value))
-        return value.map(redactSecrets);
-    if (!isRecord(value))
-        return value;
-    // Built with fromEntries: assigning a key named __proto__ would set the prototype instead.
-    return Object.fromEntries(Object.entries(value).map(([key, inner]) => {
-        if ((key === "env" || key === "headers") && isRecord(inner))
-            return [key, Object.fromEntries(Object.keys(inner).map((k) => [k, "•••"]))];
-        if (key === "url" && typeof inner === "string")
-            return [key, shownUrl(inner)];
-        if (key === "args" && "command" in value && Array.isArray(inner))
-            return [key, shownArgs(inner)];
-        return [key, redactSecrets(inner)];
-    }));
-}
-const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-export function parseFrontmatter(text) {
-    const match = FRONTMATTER.exec(text);
-    if (!match)
-        return { data: {}, body: text };
-    try {
-        const data = parseYaml(match[1] ?? "");
-        return { data: isRecord(data) ? data : {}, body: text.slice(match[0].length) };
-    }
-    catch {
-        return { data: {}, body: text.slice(match[0].length) };
-    }
-}
-/** The strings in a JSON list; anything else counts as no strings. */
-export function stringsIn(value) {
-    return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
-}
-/** A frontmatter list given as a YAML list or a comma-separated string, such as `paths`. */
-export function toStringList(value) {
-    if (typeof value === "string")
-        return value
-            .split(",")
-            .map((s) => s.trim())
-            .filter(Boolean);
-    return stringsIn(value);
-}
-export function stringField(data, key) {
-    const value = data[key];
-    return typeof value === "string" ? value.trim() : "";
-}
-/** Fingerprint of a file's text, so a change can require the file to be as it was reviewed. */
-export function revisionOf(text) {
-    return text === null ? "missing" : createHash("sha256").update(text).digest("hex").slice(0, 16);
-}
-export function shortHash(text) {
-    return createHash("sha1").update(text).digest("hex").slice(0, 10);
-}
-export async function gitRoot(dir) {
-    try {
-        const { stdout } = await run("git", ["-C", dir, "rev-parse", "--show-toplevel"], {
-            timeout: 5000,
-        });
-        // Git prints forward slashes on Windows too; normalise so path comparisons hold.
-        return stdout.trim() ? normalize(stdout.trim()) : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Every checkout of the repository `dir` is in, the main one first; empty outside git. */
-export async function worktrees(dir) {
-    try {
-        const { stdout } = await run("git", ["-C", dir, "worktree", "list", "--porcelain"], {
-            timeout: 5000,
-        });
-        return stdout
-            .split("\n")
-            .filter((line) => line.startsWith("worktree "))
-            .map((line) => normalize(line.slice("worktree ".length)));
-    }
-    catch {
-        return [];
-    }
-}
-/** Main worktree root: worktrees of one repository share Claude Code's auto memory. */
-export async function mainWorktreeRoot(dir) {
-    try {
-        const { stdout } = await run("git", ["-C", dir, "rev-parse", "--path-format=absolute", "--git-common-dir"], { timeout: 5000 });
-        const common = stdout.trim();
-        if (!common)
-            return null;
-        return common.endsWith("/.git") || common.endsWith("\\.git")
-            ? normalize(dirname(common))
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Git visibility of each path, batched into two git calls per repository. */
-export async function visibilityOf(root, paths) {
-    const result = new Map();
-    if (paths.length === 0)
-        return result;
-    if (!root) {
-        for (const p of paths)
-            result.set(p, "no-git");
-        return result;
-    }
-    const inside = paths.filter((p) => p !== root && isWithin(root, p));
-    for (const p of paths)
-        if (!inside.includes(p))
-            result.set(p, "no-git");
-    if (inside.length === 0)
-        return result;
-    const rels = new Map(inside.map((p) => [p, relative(root, p).replaceAll("\\", "/")]));
-    const tracked = await gitLines(root, ["ls-files", "--full-name", "-z", "--", ...inside], "\0");
-    // check-ignore echoes the paths it matched, and on Windows an absolute path does not come back
-    // as written, so it gets relative ones. It accepts -z only with --stdin, so its output is split
-    // by line.
-    const ignored = await gitLines(root, ["check-ignore", "--no-index", "--", ...rels.values()], "\n");
-    for (const [p, rel] of rels) {
-        if (tracked.has(rel))
-            result.set(p, "tracked");
-        else if (ignored.has(rel))
-            result.set(p, "ignored");
-        else
-            result.set(p, "untracked");
-    }
-    return result;
-}
-// Failures (including check-ignore's exit 1 for "nothing ignored") read as an empty set.
-async function gitLines(root, args, separator) {
-    try {
-        const { stdout } = await run("git", ["-C", root, ...args], { timeout: 5000 });
-        return new Set(stdout.split(separator).filter(Boolean));
-    }
-    catch {
-        return new Set();
-    }
-}
-/**
- * Markdown files under `dir`. A symlinked folder is entered once, so a link loop ends, and a link
- * to a network location is not followed. Depth and count are bounded by ccdesk, since a link can
- * lead anywhere; Claude Code's own limits are not documented.
- */
-export async function walkMarkdown(dir) {
-    const out = [];
-    const seen = new Set();
-    const walk = async (folder, depth) => {
-        const real = await resolvedPath(folder);
-        if (seen.has(real) || depth > MAX_WALK_DEPTH)
-            return;
-        seen.add(real);
-        for (const name of await listDir(folder)) {
-            if (out.length >= MAX_WALK_FILES)
-                return;
-            const path = join(folder, name);
-            if (await linksToNetwork(path))
-                continue;
-            if (await isDir(path))
-                await walk(path, depth + 1);
-            else if (name.endsWith(".md"))
-                out.push(path);
-        }
-    };
-    await walk(dir, 0);
-    return out;
-}
-const MAX_WALK_DEPTH = 8;
-const MAX_WALK_FILES = 1000;

package/dist/server/scan/path-test.js

@@ -1,136 +0,0 @@
-import { dirname, isAbsolute, join, matchesGlob, relative, resolve, sep } from "node:path";
-import {} from "../../shared/types.js";
-import {} from "./env.js";
-import { isFile, isWithin, listDir, MAX_TEXT_BYTES, parseFrontmatter, readTextFile, resolvedPath, stringsIn, toStringList, walkMarkdown, } from "./files.js";
-import { scanDirectory } from "./index.js";
-import { applySkillOverrides, readSkill } from "./inventory.js";
-/** Globs are written with forward slashes on every platform. */
-function slashed(path) {
-    return path.split(sep).join("/");
-}
-function firstMatch(globs, path) {
-    return globs.find((glob) => {
-        try {
-            return matchesGlob(path, glob);
-        }
-        catch {
-            // An invalid pattern matches nothing; the others still count (docs: memory#path-specific-rules).
-            return false;
-        }
-    });
-}
-/**
- * What Claude Code adds to context once Claude reads or edits `file` in a session started in `dir`:
- * path-scoped rules, skills with matching `paths`, and CLAUDE.md files in the folders between.
- */
-export async function testPath(env, dir, file, 
-/** The view of the start directory; a server passes one that reuses a current scan. */
-viewOf = (cwd) => scanDirectory(env, cwd)) {
-    const cwd = resolve(dir);
-    const target = isAbsolute(file) ? resolve(file) : resolve(cwd, file);
-    if (target === cwd || !isWithin(cwd, target))
-        return { file: target, inside: false, exists: false, matches: [] };
-    const view = await viewOf(cwd);
-    const projectRoot = view.gitRoot ?? cwd;
-    const matches = [];
-    const excludes = stringsIn(view.effective.find((e) => e.key === "claudeMdExcludes")?.value);
-    const overrides = view.effective.find((e) => e.key === "skillOverrides")?.value;
-    const excluded = (path) => excludes.some((glob) => firstMatch([glob], path) !== undefined);
-    // Path rules Claude Code would use at all: not excluded, not waiting for approval.
-    for (const rule of view.instructions) {
-        if (!rule.paths || rule.status !== "on-match")
-            continue;
-        // A project rule's globs are relative to the folder holding its .claude; others to the project.
-        const base = rule.scope === "project" || rule.scope === "local" ? rule.dir : projectRoot;
-        const glob = firstMatch(rule.paths, slashed(relative(base, target)));
-        if (glob)
-            matches.push({ kind: "rule", path: rule.path, scope: rule.scope, glob });
-    }
-    const realCwd = await resolvedPath(cwd);
-    const approved = view.trust.externalImports === "approved";
-    // Folders below the start directory load their own instructions, rules and skills on demand.
-    const mode = view.agentsMdMode;
-    const startSkills = new Set(view.inventory.skills.filter((s) => s.scope !== "plugin").map((s) => s.name));
-    const between = [];
-    for (let d = dirname(target); d !== cwd && isWithin(cwd, d); d = dirname(d))
-        between.unshift(d);
-    for (const folder of between) {
-        /** Whether the file is there; an excluded one or one over the limit is there but not loaded. */
-        const nested = async (name, scope) => {
-            const path = join(folder, name);
-            const file = await readTextFile(env, path);
-            if (!file)
-                return false;
-            if (!excluded(path) && file.bytes <= MAX_TEXT_BYTES)
-                matches.push({ kind: "nested", path, scope });
-            return true;
-        };
-        // managed-only leaves out files at launch, but a subfolder's CLAUDE.md and rules still load
-        // on demand (docs: memory#choose-which-instruction-files-load).
-        let hasClaudeMd = false;
-        for (const name of ["CLAUDE.md", ".claude/CLAUDE.md"])
-            if (await nested(name, "project"))
-                hasClaudeMd = true;
-        if (mode !== "managed-only" && (await nested("CLAUDE.local.md", "local")))
-            hasClaudeMd = true;
-        const agents = mode === "claude-md-and-agents-md" || (mode === "claude-md-or-agents-md" && !hasClaudeMd);
-        if (agents)
-            await nested("AGENTS.md", "project");
-        for (const path of await walkMarkdown(join(folder, ".claude", "rules"))) {
-            const text = await readTextFile(env, path);
-            if (!text || text.bytes > MAX_TEXT_BYTES || excluded(path))
-                continue;
-            // As at startup: excluded by its target's path too, and a rule linked from outside the
-            // project waits for your approval, then loads only without paths
-            // (docs: memory#share-rules-across-projects-with-symlinks).
-            const real = await resolvedPath(path);
-            const outside = !isWithin(realCwd, real) && !isWithin(await resolvedPath(folder), real);
-            const linked = text.realPath ?? (outside ? real : undefined);
-            if (linked !== undefined && excluded(linked))
-                continue;
-            const globs = toStringList(parseFrontmatter(text.text).data.paths);
-            if (!isWithin(realCwd, real) && (!approved || globs.length > 0))
-                continue;
-            const glob = globs.length === 0 ? undefined : firstMatch(globs, slashed(relative(folder, target)));
-            if (globs.length === 0 || glob)
-                matches.push({ kind: "nested", path, scope: "project", ...(glob ? { glob } : {}) });
-        }
-        // Only skills Claude may pick itself: not off, user-invocable-only or disable-model-invocation;
-        // one with paths only for a matching file, its globs read from its folder like a rule's.
-        for (const name of await listDir(join(folder, ".claude", "skills"))) {
-            const skill = await readSkill(env, join(folder, ".claude", "skills", name), "project");
-            if (!skill)
-                continue;
-            applySkillOverrides([skill], overrides);
-            if (skill.listed === false)
-                continue;
-            const glob = skill.paths && firstMatch(skill.paths, slashed(relative(folder, target)));
-            if (skill.paths && !glob)
-                continue;
-            // A nested skill whose folder name another skill has is called by its folder as well, as
-            // apps/web:deploy (docs: skills#how-a-skill-gets-its-command-name).
-            matches.push({
-                kind: "skill",
-                path: skill.path,
-                scope: "project",
-                name: startSkills.has(name) ? `${slashed(relative(cwd, folder))}:${name}` : skill.name,
-                ...(glob ? { glob } : {}),
-            });
-        }
-    }
-    // Skills Claude can pick on its own; one with disable-model-invocation only runs when you call it.
-    for (const skill of view.inventory.skills) {
-        if (!skill.paths || skill.listed === false || skill.shadowedBy)
-            continue;
-        const glob = firstMatch(skill.paths, slashed(relative(projectRoot, target)));
-        if (glob)
-            matches.push({
-                kind: "skill",
-                path: skill.path,
-                scope: skill.scope,
-                glob,
-                name: skill.id ?? skill.name,
-            });
-    }
-    return { file: target, inside: true, exists: await isFile(target), matches };
-}

package/dist/server/schema.js

@@ -1,15 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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);
-}