ccdesk 0.0.0-stage → 0.1.0

package/dist/server/scan/files.js

@@ -0,0 +1,390 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstat, open, readdir, readFile, 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 } from "yaml";
+import {} from "../../shared/types.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.
+ */
+export 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));
+}
+/**
+ * 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 or memory backup. 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.
+ */
+export function shownText(text) {
+    if (text === null)
+        return null;
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+    return typeof data === "object" && data !== null
+        ? `${JSON.stringify(redactSecrets(data), null, 2)}\n`
+        : text;
+}
+/** 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);
+    return rel === "" || (!rel.startsWith("..") && !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(path) {
+    try {
+        if (await linksToNetwork(path))
+            return null;
+        if (await leadsToSecret(path))
+            return null;
+        const real = await realpath(path);
+        const info = await stat(path);
+        if (!info.isFile())
+            return null;
+        const handle = await open(path, "r");
+        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;
+    }
+}
+export async function readJsonObject(path) {
+    let raw;
+    try {
+        if (await leadsToSecret(path))
+            return { ok: false, missing: false, error: "ccdesk does not read credentials" };
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT";
+        return { ok: false, missing, error: String(error) };
+    }
+    try {
+        const data = JSON.parse(raw);
+        if (!isRecord(data))
+            return { ok: false, missing: false, error: "not a JSON object" };
+        return { ok: true, data };
+    }
+    catch (error) {
+        return { ok: false, missing: false, 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(/\?.*$/, "?•••");
+    }
+}
+/**
+ * Replace values that commonly hold secrets with a placeholder, keeping the keys: env and headers
+ * values, and the user, password and query of a `url`.
+ */
+export function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (!isRecord(value))
+        return value;
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+        if ((key === "env" || key === "headers") && isRecord(inner)) {
+            out[key] = Object.fromEntries(Object.keys(inner).map((k) => [k, "•••"]));
+        }
+        else if (key === "url" && typeof inner === "string") {
+            out[key] = shownUrl(inner);
+        }
+        else {
+            out[key] = redactSecrets(inner);
+        }
+    }
+    return out;
+}
+export function parseFrontmatter(text) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.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/index.js

@@ -0,0 +1,266 @@
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import {} from "../../shared/types.js";
+import { buildContext } from "./context.js";
+import {} from "./env.js";
+import { gitRoot, isDir, isFile, isRecord, mainWorktreeRoot, readJsonObject, stringsIn, visibilityOf, } from "./files.js";
+import { AGENTS_MD_MODES, resolveInstructions } from "./instructions.js";
+import { readInventory } from "./inventory.js";
+import { readMemoryStore, storeDirName } from "./memory.js";
+import { permissionsOf, trustWaits } from "./permissions.js";
+import { listProjects } from "./projects.js";
+import { effectiveSettings, readSettingsLayers } from "./settings.js";
+import { builtinTools } from "./tools.js";
+async function readClaudeJson(env) {
+    const result = await readJsonObject(env.claudeJson);
+    return result.ok ? result.data : null;
+}
+export async function scanOverview(env, launchDir) {
+    const claudeJson = await readClaudeJson(env);
+    const projects = await listProjects(env, claudeJson, launchDir);
+    const hashesByName = new Map();
+    const memoryCatalog = [];
+    for (const project of projects) {
+        for (const memory of project.store?.memories ?? []) {
+            memoryCatalog.push({
+                projectPath: project.path,
+                path: memory.path,
+                name: memory.name,
+                description: memory.description,
+                type: memory.type,
+            });
+            const list = hashesByName.get(memory.name) ?? [];
+            list.push({ projectPath: project.path, hash: memory.hash });
+            hashesByName.set(memory.name, list);
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        home: env.home,
+        claudeDir: env.claudeDir,
+        launchDir: resolve(launchDir),
+        platform: env.platform,
+        projects: projects.map(({ store: _store, ...summary }) => summary),
+        sharedMemories: [...hashesByName.entries()]
+            .filter(([, stores]) => stores.length > 1)
+            .map(([name, stores]) => ({ name, stores }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        memoryCatalog,
+    };
+}
+/** Everything Claude Code reads when started in `dir`. */
+export async function scanDirectory(env, dir) {
+    const path = resolve(dir);
+    const exists = await isDir(path);
+    const claudeJson = await readClaudeJson(env);
+    const root = exists ? await gitRoot(path) : null;
+    const settings = await readSettingsLayers(env, path);
+    const effective = effectiveSettings(settings);
+    const mode = agentsMdMode(settings);
+    const excludes = effective.find((s) => s.key === "claudeMdExcludes")?.value;
+    const mainRoot = exists ? await mainWorktreeRoot(path) : null;
+    const trust = trustOf(env, claudeJson, path, mainRoot ?? root);
+    const managedLayer = settings.find((l) => l.scope === "managed");
+    const managedClaudeMd = managedLayer?.data?.claudeMd;
+    const problems = [];
+    const instructions = await resolveInstructions({
+        env,
+        cwd: path,
+        mode,
+        excludes: stringsIn(excludes),
+        externalImports: trust.externalImports,
+        managedClaudeMd: managedLayer && typeof managedClaudeMd === "string"
+            ? { path: `${managedLayer.path}#claudeMd`, text: managedClaudeMd }
+            : null,
+        problems,
+    });
+    const inventory = await readInventory({
+        env,
+        projectDir: path,
+        gitRoot: root,
+        layers: settings,
+        claudeJson,
+        trust,
+    });
+    // Every project file that shapes Claude here, so the UI can say who sees each one.
+    const mcpJson = join(path, ".mcp.json");
+    const projectFiles = [
+        ...instructions.filter((i) => i.scope === "project" || i.scope === "local").map((i) => i.path),
+        ...settings
+            .filter((s) => s.exists && (s.scope === "project" || s.scope === "local"))
+            .map((s) => s.path),
+        ...((await isFile(mcpJson)) ? [mcpJson] : []),
+        ...[...inventory.agents, ...inventory.skills, ...inventory.commands, ...inventory.outputStyles]
+            .filter((e) => e.scope === "project" || e.scope === "local")
+            .map((e) => e.path),
+    ];
+    const visibility = await visibilityOf(root, projectFiles);
+    for (const item of [...instructions, ...settings]) {
+        const v = visibility.get(item.path);
+        if (v)
+            item.visibility = v;
+    }
+    let sharing = null;
+    if (root) {
+        sharing = { tracked: [], untracked: [], ignored: [] };
+        for (const file of new Set(projectFiles)) {
+            const v = visibility.get(file);
+            // Shown as repository paths, with forward slashes on every platform.
+            const rel = relative(root, file).replaceAll("\\", "/");
+            if (v === "tracked")
+                sharing.tracked.push(rel);
+            else if (v === "untracked")
+                sharing.untracked.push(rel);
+            else if (v === "ignored")
+                sharing.ignored.push(rel);
+        }
+    }
+    // docs: permissions#when-your-local-settings-file-needs-trust
+    const localFromRepository = settings.some((l) => l.scope === "local" && l.visibility === "tracked");
+    const trustOptions = { trust, inConfigHome: isConfigHome(env, path), localFromRepository };
+    const memory = await readMemory(env, mainRoot, path, effective, trustOptions);
+    const permissions = permissionsOf(settings, trustOptions);
+    for (const l of settings)
+        if (l.error)
+            problems.push({ path: l.path, error: l.error });
+    const mcp = await readJsonObject(mcpJson);
+    if (!mcp.ok && !mcp.missing)
+        problems.push({ path: mcpJson, error: mcp.error });
+    return {
+        path,
+        exists,
+        gitRoot: root,
+        agentsMdMode: mode,
+        instructions,
+        settings,
+        effective,
+        memory,
+        inventory,
+        context: await buildContext({
+            env,
+            projectRoot: root ?? path,
+            instructions,
+            memory,
+            inventory,
+            effective,
+        }),
+        permissions,
+        tools: builtinTools(permissions, inventory.hooks),
+        trust,
+        problems,
+        sharing,
+    };
+}
+/** Your home directory, or the folder whose .claude is CLAUDE_CONFIG_DIR. */
+function isConfigHome(env, path) {
+    return path === env.home || join(path, ".claude") === env.claudeDir;
+}
+/**
+ * Your answers to Claude Code's trust dialogs, from ~/.claude.json (docs: permissions#project-allow-rules-and-workspace-trust).
+ * In a repository the key is the main checkout's root; outside one it is the folder, and a trusted
+ * parent folder covers it. In your home directory trust lasts one session and is never saved.
+ */
+function trustOf(env, claudeJson, path, repositoryRoot) {
+    const projects = isRecord(claudeJson?.projects) ? claudeJson.projects : {};
+    const entry = (key) => (isRecord(projects[key]) ? projects[key] : {});
+    const root = repositoryRoot ?? path;
+    const own = entry(root);
+    const trust = {
+        root,
+        trusted: own.hasTrustDialogAccepted === true,
+        sessionOnly: path === env.home,
+        // These two keys are not documented; they are what Claude Code writes for the import dialog.
+        externalImports: own.hasClaudeMdExternalIncludesApproved === true
+            ? "approved"
+            : own.hasClaudeMdExternalIncludesWarningShown === true
+                ? "declined"
+                : "not-asked",
+    };
+    if (!trust.trusted && !repositoryRoot)
+        for (let d = dirname(path); d !== dirname(d); d = dirname(d))
+            if (entry(d).hasTrustDialogAccepted === true) {
+                trust.inheritedFrom = d;
+                break;
+            }
+    return trust;
+}
+/**
+ * The auto memory Claude Code uses here (docs: memory#storage-location, settings-reference#automemoryenabled).
+ * Worktrees and subdirectories of one repository share one store. The store is returned even
+ * when its folder does not exist yet, so a note about memory being off still shows.
+ */
+async function readMemory(env, mainRoot, path, effective, trustOptions) {
+    const key = mainRoot ?? path;
+    const setting = effective.find((s) => s.key === "autoMemoryDirectory");
+    // A value from a repository file counts once the folder is trusted, like hooks (docs:
+    // settings-reference#automemorydirectory); until then the next file down that sets it decides.
+    const waitsForTrust = trustWaits(trustOptions);
+    const candidates = setting
+        ? [{ scope: setting.from[0], value: setting.value }, ...setting.overridden]
+        : [];
+    const waiting = candidates.find((c) => c.scope && waitsForTrust(c.scope));
+    const custom = candidates.find((c) => c.scope && !waitsForTrust(c.scope));
+    const customDir = typeof custom?.value === "string" ? expandHome(env, custom.value) : null;
+    const storeName = env.projectDirName ?? storeDirName(key);
+    const dir = customDir ?? join(env.claudeDir, "projects", storeName, "memory");
+    const store = (await readMemoryStore(dir, key)) ?? {
+        dir,
+        loaded: true,
+        projectPath: key,
+        index: null,
+        memories: [],
+    };
+    if (customDir)
+        store.custom = true;
+    const disable = env.disableAutoMemory;
+    const enabled = effective.find((s) => s.key === "autoMemoryEnabled");
+    const fromRepository = custom?.scope === "project" || (custom?.scope === "local" && trustOptions.localFromRepository);
+    if (disable === "1" || disable === "true") {
+        store.loaded = false;
+        store.note = "CLAUDE_CODE_DISABLE_AUTO_MEMORY turns auto memory off in this shell";
+    }
+    else if (disable === undefined && enabled?.value === false) {
+        store.loaded = false;
+        store.note = `autoMemoryEnabled is false in ${enabled.from.join(", ")} settings`;
+    }
+    else if (customDir && custom && fromRepository && blocksOutsideReads(effective)) {
+        // docs: settings-reference#permissions-blockreadsoutsideworkingdirectories
+        store.loaded = false;
+        store.note =
+            "autoMemoryDirectory comes from repository settings and blockReadsOutsideWorkingDirectories is on, so Claude Code loads no auto memory from it";
+    }
+    else if (customDir && custom) {
+        store.note = `autoMemoryDirectory in ${custom.scope} settings points here; ccdesk only changes stores under ~/.claude/projects`;
+    }
+    else if (waiting) {
+        store.note = `autoMemoryDirectory in ${waiting.scope} settings takes over once you trust this folder; until then Claude Code uses this store`;
+    }
+    else if (env.projectDirName) {
+        store.note = `CLAUDE_CODE_PROJECT_DIR_NAME names this store "${env.projectDirName}" in every project`;
+    }
+    return store;
+}
+function blocksOutsideReads(effective) {
+    const permissions = effective.find((s) => s.key === "permissions")?.value;
+    return isRecord(permissions) && permissions.blockReadsOutsideWorkingDirectories === true;
+}
+/** autoMemoryDirectory takes an absolute or ~/ path; anything else is not a valid value. */
+function expandHome(env, path) {
+    if (path.startsWith("~/"))
+        return join(env.home, path.slice(2));
+    return isAbsolute(path) ? path : null;
+}
+/** Read from user, --settings or managed settings only; project and local files are ignored for it. */
+function agentsMdMode(layers) {
+    for (const scope of ["managed", "user"]) {
+        const configs = layers.find((l) => l.scope === scope)?.data?.pluginConfigs;
+        if (!isRecord(configs))
+            continue;
+        for (const id of ["cc-plugin-agents-md@builtin", "agents-md@builtin"]) {
+            const entry = configs[id];
+            const value = isRecord(entry) && isRecord(entry.options) ? entry.options.instructionFiles : undefined;
+            if (typeof value === "string" && AGENTS_MD_MODES.includes(value))
+                return value;
+        }
+    }
+    return "claude-md-or-agents-md";
+}