@cairnkeep/cli 2.3.0 → 2.4.0

package/mcp-memory-server/dist/eval-workspace.js

@@ -0,0 +1,313 @@
+import { constants, existsSync } from "node:fs";
+import { chmod, lstat, mkdir, mkdtemp, open, readFile, realpath, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { canonicalDigest } from "./eval-schema.js";
+import { EvalProcessError, runBoundedCommand, } from "./eval-process.js";
+const GIT_TIMEOUT_MS = 120_000;
+const GIT_OUTPUT_LIMIT = 64 * 1024;
+const CLEANUP_TIMEOUT_MS = 120_000;
+const BINDING_LIMIT = 64 * 1024;
+function isContained(root, candidate) {
+    const rel = relative(root, candidate);
+    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}
+async function assertPrivateDirectory(path) {
+    const info = await lstat(path);
+    if (info.isSymbolicLink() || !info.isDirectory())
+        throw new Error("unsafe_workspace_root");
+    return realpath(path);
+}
+async function privateDirectory(path) {
+    await mkdir(path, { recursive: false, mode: 0o700 });
+    await chmod(path, 0o700);
+}
+async function gitCommand(repository, args, stdoutMode) {
+    return runBoundedCommand({
+        command: { program: "git", args: ["-C", repository, ...args] },
+        cwd: repository,
+        env: process.env,
+        stdout_mode: stdoutMode,
+        timeout_ms: GIT_TIMEOUT_MS,
+        max_stdout_bytes: stdoutMode === "raw" ? GIT_OUTPUT_LIMIT : 0,
+    });
+}
+function requireSuccessfulCommand(result, code) {
+    if (result.exit_code !== 0 || result.signal !== null || result.cleanup !== "closed")
+        throw new Error(code);
+}
+async function verifyGitWorkspace(workspace) {
+    const head = await gitCommand(workspace.source_path, ["rev-parse", "--verify", "HEAD^{commit}"], "raw");
+    requireSuccessfulCommand(head, "workspace_head_query_failed");
+    if (head.stdout?.trim() !== workspace.source_revision)
+        throw new Error("workspace_revision_mismatch");
+    const status = await gitCommand(workspace.source_path, ["status", "--porcelain", "--untracked-files=all"], "raw");
+    requireSuccessfulCommand(status, "workspace_status_query_failed");
+    if (status.stdout?.trim() !== "")
+        throw new Error("workspace_not_clean");
+}
+async function validateBundledBinding(plan) {
+    if (plan.source.kind !== "bundled_fake" || plan.task_set.source.kind !== "bundled_fake") {
+        throw new Error("bundled_source_mismatch");
+    }
+    if (canonicalDigest(plan.task_set) !== plan.task_set_digest)
+        throw new Error("task_set_digest_mismatch");
+    let handle;
+    let binding;
+    try {
+        handle = await open(plan.source.binding_path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > BINDING_LIMIT)
+            throw new Error("unsafe_bundled_binding");
+        const bytes = await handle.readFile();
+        if (bytes.byteLength > BINDING_LIMIT)
+            throw new Error("unsafe_bundled_binding");
+        binding = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new Error("invalid_bundled_binding");
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    if (!binding || typeof binding !== "object" || Array.isArray(binding))
+        throw new Error("invalid_bundled_binding");
+    const record = binding;
+    if (canonicalDigest(Object.keys(record).sort()) !== canonicalDigest([
+        "identifier", "package_version", "schema_version", "task_set_digest",
+    ])
+        || record.schema_version !== plan.schema_version
+        || record.identifier !== plan.source.identifier
+        || record.package_version !== plan.source.package_version
+        || record.task_set_digest !== plan.task_set_digest) {
+        throw new Error("bundled_binding_mismatch");
+    }
+}
+async function materializeBundledSource(plan, sourcePath) {
+    await validateBundledBinding(plan);
+    if (plan.task_set.source.kind !== "bundled_fake")
+        throw new Error("bundled_source_mismatch");
+    await privateDirectory(sourcePath);
+    for (const file of plan.task_set.source.files) {
+        const destination = resolve(sourcePath, file.path);
+        if (!isContained(sourcePath, destination) || destination === sourcePath)
+            throw new Error("bundled_path_escape");
+        const segments = relative(sourcePath, dirname(destination)).split(sep).filter(Boolean);
+        let parent = sourcePath;
+        for (const segment of segments) {
+            parent = join(parent, segment);
+            if (!isContained(sourcePath, parent))
+                throw new Error("bundled_path_escape");
+            if (!existsSync(parent))
+                await privateDirectory(parent);
+            else if ((await lstat(parent)).isSymbolicLink() || !(await lstat(parent)).isDirectory()) {
+                throw new Error("bundled_path_unsafe");
+            }
+        }
+        await writeFile(destination, Buffer.from(file.content, "utf8"), { flag: "wx", mode: 0o600 });
+        const info = await lstat(destination);
+        if (info.isSymbolicLink() || !info.isFile())
+            throw new Error("bundled_path_unsafe");
+        if (!Buffer.from(file.content, "utf8").equals(await readFile(destination)))
+            throw new Error("bundled_source_mismatch");
+    }
+    if (canonicalDigest(plan.task_set) !== plan.task_set_digest)
+        throw new Error("task_set_digest_mismatch");
+}
+function workspaceEnvironment(workspace, extra) {
+    return {
+        ...process.env,
+        ...extra,
+        HOME: workspace.home_path,
+        TMPDIR: workspace.temp_path,
+        XDG_CACHE_HOME: join(workspace.home_path, ".cache"),
+        XDG_CONFIG_HOME: join(workspace.home_path, ".config"),
+        XDG_DATA_HOME: join(workspace.home_path, ".local", "share"),
+    };
+}
+export async function createEvalWorkspace(options) {
+    const taskIndex = options.plan.task_set.tasks.findIndex((candidate) => candidate.id === options.row.task_id);
+    if (taskIndex < 0)
+        throw new Error("unknown_schedule_task");
+    const task = options.plan.task_set.tasks[taskIndex];
+    if (!task)
+        throw new Error("unknown_schedule_task");
+    const root = await assertPrivateDirectory(resolve(options.temporary_root ?? tmpdir()));
+    const parent = await mkdtemp(join(root, "cairn-eval-workspace-"));
+    await chmod(parent, 0o700);
+    const workspace = {
+        observation_id: options.row.observation_id,
+        task_id: task.id,
+        parent_path: parent,
+        source_path: join(parent, "source"),
+        workspace_path: "",
+        notes_path: join(parent, "notes"),
+        output_path: join(parent, "output"),
+        home_path: join(parent, "home"),
+        temp_path: join(parent, "tmp"),
+        source_revision: options.plan.source.kind === "git" ? options.plan.source.revision : options.plan.task_set_digest,
+        source_kind: options.plan.source.kind,
+        repository_root: options.plan.source.kind === "git" ? options.plan.source.repository_root : null,
+        worktree_registered: false,
+        task,
+        prepare_program: options.plan.resolved_programs.prepare[taskIndex] ?? task.prepare.program,
+        verify_program: options.plan.resolved_programs.verify[taskIndex] ?? task.verify.program,
+    };
+    try {
+        if (options.plan.source.kind === "git") {
+            const added = await gitCommand(options.plan.source.repository_root, ["worktree", "add", "--detach", workspace.source_path, options.plan.source.revision], "exit-only");
+            requireSuccessfulCommand(added, "workspace_add_failed");
+            workspace.worktree_registered = true;
+            await verifyGitWorkspace(workspace);
+        }
+        else {
+            await materializeBundledSource(options.plan, workspace.source_path);
+        }
+        workspace.workspace_path = resolve(workspace.source_path, task.workspace.path);
+        if (!isContained(workspace.source_path, workspace.workspace_path))
+            throw new Error("workspace_path_escape");
+        const realTaskRoot = await assertPrivateDirectory(workspace.workspace_path);
+        if (!isContained(await realpath(workspace.source_path), realTaskRoot))
+            throw new Error("workspace_path_escape");
+        workspace.workspace_path = realTaskRoot;
+        for (const directory of [workspace.notes_path, workspace.output_path, workspace.home_path, workspace.temp_path]) {
+            await privateDirectory(directory);
+        }
+        return workspace;
+    }
+    catch (error) {
+        await cleanupEvalWorkspace(workspace).catch(() => undefined);
+        throw error;
+    }
+}
+export async function runTaskPreparation(workspace, options = {}) {
+    return runBoundedCommand({
+        command: { program: workspace.prepare_program, args: workspace.task.prepare.args },
+        cwd: workspace.workspace_path,
+        env: workspaceEnvironment(workspace, options.env),
+        stdout_mode: "exit-only",
+        timeout_ms: workspace.task.limits.elapsed_ms,
+        max_stdout_bytes: 0,
+        kill_grace_ms: options.kill_grace_ms,
+        signal: options.signal,
+    });
+}
+function verifierReason(code) {
+    return `verifier_${code}`;
+}
+export async function runTaskVerifier(workspace, options) {
+    if (!options.adapter_completed) {
+        return {
+            pass_state: "unknown",
+            terminal_state: "completed",
+            verifier_state: "not_run",
+            reason: "adapter_not_completed",
+            process: null,
+        };
+    }
+    try {
+        const result = await runBoundedCommand({
+            command: { program: workspace.verify_program, args: workspace.task.verify.args },
+            cwd: workspace.workspace_path,
+            env: workspaceEnvironment(workspace, options.env),
+            stdout_mode: "exit-only",
+            timeout_ms: workspace.task.limits.elapsed_ms,
+            max_stdout_bytes: 0,
+            kill_grace_ms: options.kill_grace_ms,
+            signal: options.signal,
+        });
+        if (result.signal !== null || result.cleanup !== "closed" || result.exit_code === null) {
+            return {
+                pass_state: "unknown",
+                terminal_state: "completed",
+                verifier_state: "error",
+                reason: result.signal !== null ? "verifier_signal" : "verifier_cleanup_failed",
+                process: result,
+            };
+        }
+        const passed = result.exit_code === 0;
+        return {
+            pass_state: passed ? "passed" : "failed",
+            terminal_state: passed ? "completed" : "verifier_failed",
+            verifier_state: "completed",
+            reason: passed ? null : "verifier_nonzero",
+            process: result,
+        };
+    }
+    catch (error) {
+        if (!(error instanceof EvalProcessError))
+            throw error;
+        if (error.code === "cancelled") {
+            return {
+                pass_state: "unknown",
+                terminal_state: "cancelled",
+                verifier_state: "error",
+                reason: "verifier_cancelled",
+                process: {
+                    exit_code: error.exit_code,
+                    signal: error.signal,
+                    cleanup: error.cleanup,
+                    termination_scope: error.termination_scope,
+                },
+            };
+        }
+        return {
+            pass_state: "unknown",
+            terminal_state: "completed",
+            verifier_state: "error",
+            reason: verifierReason(error.code),
+            process: null,
+        };
+    }
+}
+async function removeParent(path) {
+    try {
+        const result = await runBoundedCommand({
+            command: {
+                program: process.execPath,
+                args: ["-e", "import('node:fs/promises').then(fs=>fs.rm(process.argv[1],{recursive:true,force:true}))", path],
+            },
+            stdout_mode: "exit-only",
+            timeout_ms: CLEANUP_TIMEOUT_MS,
+            max_stdout_bytes: 0,
+        });
+        return result.exit_code === 0 && !existsSync(path);
+    }
+    catch {
+        return false;
+    }
+}
+export async function cleanupEvalWorkspace(workspace) {
+    let registration = "not_applicable";
+    if (workspace.worktree_registered && workspace.repository_root) {
+        try {
+            const removed = await gitCommand(workspace.repository_root, ["worktree", "remove", "--force", workspace.source_path], "exit-only");
+            registration = removed.exit_code === 0 ? "removed" : "failed";
+        }
+        catch {
+            registration = "failed";
+        }
+    }
+    const parentRemoved = await removeParent(workspace.parent_path);
+    if (workspace.worktree_registered && workspace.repository_root && registration === "failed") {
+        try {
+            await gitCommand(workspace.repository_root, ["worktree", "prune", "--expire", "now"], "exit-only");
+            const listed = await gitCommand(workspace.repository_root, ["worktree", "list", "--porcelain"], "raw");
+            if (listed.exit_code === 0 && !listed.stdout?.includes(workspace.source_path))
+                registration = "removed";
+        }
+        catch {
+            registration = "failed";
+        }
+    }
+    return {
+        status: parentRemoved && registration !== "failed" ? "closed" : "failed",
+        worktree_registration: registration,
+        parent: parentRemoved ? "removed" : "failed",
+    };
+}
+export function evalWorkspaceCommand(workspace, kind) {
+    return kind === "prepare"
+        ? { program: workspace.prepare_program, args: [...workspace.task.prepare.args] }
+        : { program: workspace.verify_program, args: [...workspace.task.verify.args] };
+}

package/mcp-memory-server/dist/failure-signature.js

@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto";
+import { relative, resolve } from "node:path";
+import { failureSignatureSchema } from "./note-schema.js";
+const ANSI = /\u001b(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001b\\))/g;
+const INTERNAL_FRAME = /(?:node:internal|internal\/process|processTicksAndRejections|__node_internal|<anonymous>)/i;
+function hash(domain, value) {
+    return createHash("sha256")
+        .update(`cairnkeep:hindsight:v1:${domain}\0`)
+        .update(JSON.stringify(value))
+        .digest("hex");
+}
+function safePath(value, root) {
+    let path = value.trim().replace(/^['"(]|['"),]$/g, "").replaceAll("\\", "/");
+    path = path.replace(/:\d+(?::\d+)?$/, "");
+    if (root) {
+        const normalizedRoot = resolve(root).replaceAll("\\", "/").replace(/\/$/, "");
+        if (path === normalizedRoot)
+            return "";
+        if (path.startsWith(`${normalizedRoot}/`))
+            path = path.slice(normalizedRoot.length + 1);
+        else {
+            const candidate = relative(normalizedRoot, path).replaceAll("\\", "/");
+            if (!candidate.startsWith("../") && candidate !== "..")
+                path = candidate;
+        }
+    }
+    const projectTail = path.match(/(?:^|\/)((?:src|pkg|lib|test|tests|app)\/[^\s:()]+)$/i);
+    if (projectTail)
+        path = projectTail[1];
+    path = path.replace(/^\.?\//, "").replace(/^\/+/, "");
+    return path.slice(0, 1024);
+}
+function normalizeVolatile(value, root) {
+    let result = value.replace(ANSI, "").replaceAll("\r", "");
+    if (root) {
+        const normalizedRoot = resolve(root).replaceAll("\\", "/").replace(/\/$/, "");
+        result = result.replaceAll(normalizedRoot, "<root>");
+    }
+    return result
+        .replace(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/gi, "<timestamp>")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi, "<uuid>")
+        .replace(/\breq_[a-z0-9_-]{16,}\b/gi, "req_<id>")
+        .replace(/\bpid\s*[=:]?\s*\d+\b/gi, "pid <pid>")
+        .replace(/\b0x[0-9a-f]+\b/gi, "<address>")
+        .replace(/:(\d+)(?::\d+)?(?=\b|\))/g, ":<line>")
+        .replace(/[\t\u00a0 ]+/g, " ")
+        .trim();
+}
+function parseFrames(text, root) {
+    const frames = [];
+    const add = (fn, file) => {
+        const normalizedFunction = fn.replace(/^async\s+/, "").trim();
+        const normalizedFile = safePath(file, root);
+        if (!normalizedFunction || !normalizedFile || INTERNAL_FRAME.test(`${normalizedFunction} ${normalizedFile}`))
+            return;
+        if (!frames.some((frame) => frame.function === normalizedFunction && frame.file === normalizedFile)) {
+            frames.push({ function: normalizedFunction.slice(0, 512), file: normalizedFile });
+        }
+    };
+    for (const rawLine of text.replace(ANSI, "").replaceAll("\r", "").split("\n")) {
+        const line = rawLine.trim();
+        let match = line.match(/^at\s+(?:async\s+)?(.+?)\s+\((.+?):\d+(?::\d+)?\)$/);
+        if (match) {
+            add(match[1], match[2]);
+            continue;
+        }
+        match = line.match(/^at\s+(.+?):\d+(?::\d+)?$/);
+        if (match) {
+            add("<module>", match[1]);
+            continue;
+        }
+        match = line.match(/^File\s+["'](.+?)["'],\s+line\s+\d+,\s+in\s+(.+)$/);
+        if (match) {
+            add(match[2], match[1]);
+            continue;
+        }
+        match = line.match(/^at\s+([\w.$<>]+)\(([^():]+\.java):\d+\)$/);
+        if (match) {
+            add(match[1], match[2]);
+            continue;
+        }
+        match = line.match(/^\d+:\s+(?:0x[0-9a-f]+\s+-\s+)?(.+)$/i);
+        if (match) {
+            const source = text.match(/(?:^|[\s,])((?:\/[^\s,:]+)*\/(?:src|pkg|lib|test|tests)\/[^\s,:]+):\d+(?::\d+)?/im);
+            if (source)
+                add(match[1], source[1]);
+        }
+    }
+    return frames.slice(0, 16);
+}
+function selectMessage(text, root) {
+    const lines = normalizeVolatile(text, root).split("\n").map((line) => line.trim()).filter(Boolean);
+    const python = [...lines].reverse().find((line) => /^[\w.]+(?:Error|Exception):/.test(line) || /^[A-Z][\w.]*Error:/.test(line));
+    if (lines.some((line) => /^Traceback \(/.test(line)) && python)
+        return python;
+    const first = lines.find((line) => !/^(?:at\s+|File\s+|stack backtrace:|\d+:\s+(?:<address>|0x))/i.test(line));
+    if (!first)
+        return "unknown failure";
+    return first
+        .replace(/,\s*(?:<root>|\/?(?:[^\s,]+\/)*(?:src|pkg|lib|test|tests)\/[^\s,:]+):<line>$/i, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 4096);
+}
+function familyFor(message) {
+    if (/\bpanicked at\b/i.test(message))
+        return "panic";
+    const diagnostic = message.match(/^([A-Z]{2,}\d{3,}):/);
+    if (diagnostic)
+        return diagnostic[1].toLowerCase();
+    const typed = message.match(/^([A-Za-z_$][\w.$-]*(?:Error|Exception))\s*:/);
+    const raw = typed?.[1].split(".").at(-1) ?? message.split(":", 1)[0] ?? "failure";
+    return raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 128) || "failure";
+}
+export function buildFailureSignature(text, options = {}) {
+    const normalizedMessage = selectMessage(text, options.root);
+    const frames = parseFrames(text, options.root);
+    const explicitComponent = options.component ? safePath(options.component, options.root) : "";
+    const sourceInMessage = text.match(/(?:^|[\s,])((?:\/[^\s,:]+)*\/(?:src|pkg|lib|test|tests)\/[^\s,:]+):\d+(?::\d+)?/im);
+    const component = explicitComponent || frames[0]?.file || (sourceInMessage ? safePath(sourceInMessage[1], options.root) : "");
+    const family = familyFor(normalizedMessage);
+    const normalizedForHash = normalizedMessage.toLocaleLowerCase("en-US");
+    const stackDigest = frames.length > 0 ? hash("stack", frames) : "";
+    const fullDigest = hash("full", { family, message: normalizedForHash, stack_digest: stackDigest, component });
+    const signature = {
+        signature_version: 1,
+        family,
+        normalized_message: normalizedMessage,
+        stack_digest: stackDigest,
+        component,
+        frames,
+        lookup_keys: {
+            full: `v1:full:${fullDigest}`,
+            message_stack: `v1:message-stack:${hash("message-stack", { family, message: normalizedForHash, stack_digest: stackDigest })}`,
+            message_component: `v1:message-component:${hash("message-component", { family, message: normalizedForHash, component })}`,
+            message: `v1:message:${hash("message", { family, message: normalizedForHash })}`,
+        },
+        fingerprint: fullDigest,
+    };
+    return failureSignatureSchema.parse(signature);
+}