open-multi-agent-kit 0.78.0

package/dist/util/secret-mask.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Mask sensitive tokens, credentials, and secrets in free-text output.
+ * Safe to apply to error messages, command output, diagnostic text, and URLs.
+ */
+export declare function maskSensitiveText(value: string): string;

package/dist/util/secret-mask.js

@@ -0,0 +1,41 @@
+/**
+ * Mask sensitive tokens, credentials, and secrets in free-text output.
+ * Safe to apply to error messages, command output, diagnostic text, and URLs.
+ */
+export function maskSensitiveText(value) {
+    if (typeof value !== "string")
+        return String(value ?? "");
+    return (value
+        // Bearer tokens
+        .replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1***")
+        // OpenAI keys
+        .replace(/\bsk-(?:proj|svcacct)-[A-Za-z0-9_-]{8,}\b/g, "sk-***")
+        .replace(/\bsk-[A-Za-z0-9_-]{20,}\b/g, "sk-***")
+        // GitHub PATs
+        .replace(/\bghp_[A-Za-z0-9]{36,}\b/g, "ghp_***")
+        .replace(/\bgithub_pat_[A-Za-z0-9]{22,}\b/g, "github_pat_***")
+        // GitLab PATs
+        .replace(/\bglpat-[A-Za-z0-9_-]{10,}\b/g, "glpat-***")
+        // JWT-like tokens (three base64url segments)
+        .replace(/\beyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\b/g, "***")
+        // OAuth / access / refresh / session / id tokens as key=value or key: value
+        .replace(/((?:oauth|access|refresh|session|id)[_-]?token\s*[:=]\s*)[^\s"';,]+/gi, "$1***")
+        // OMK session/run/goal identifiers
+        .replace(/\b(OMK_[A-Z_][A-Za-z0-9_]*)\s*[:=]\s*[^\s"';,]+/g, "$1=***")
+        // CLI flags like --api-key=...
+        .replace(/(--(?:api[-_]?key|api[-_]?token|token|key|secret|password|client[-_]?secret|x[-_]?auth[-_]?token)(?:=|\s+))[^"'`\s;]+/gi, "$1***")
+        // Env var assignments with secret-like names
+        .replace(/([A-Za-z_][A-Za-z0-9_]*(?:SECRET|TOKEN|KEY|PASSWORD|PASSWD|CREDENTIAL|AUTH|COOKIE|SESSION|PRIVATE|DSN|PAT|URI|JWT|BEARER|OAUTH)[A-Za-z0-9_]*\s*=\s*)[^"'`\s;]+/gi, "$1***")
+        // URL query parameters with secrets
+        .replace(/([?&](?:token|api[-_]?key|key|secret|password|auth|credential|session|bearer|access[-_]?token|refresh[-_]?token|client[-_]?secret|x[-_]?auth[-_]?token|signature|sig|jwt|private[-_]?key|pat|dsn)=)[^&#"'`\s]+/gi, "$1***")
+        // URL fragments after hash
+        .replace(/(https?:\/\/[^#\s"'`]+)#[^ \t\r\n"'`]+/gi, "$1#***")
+        // URL credentials user:pass@
+        .replace(/[A-Za-z0-9._%+-]+:[A-Za-z0-9._%+-]+@/g, "***@")
+        // Authorization / Proxy-Authorization headers
+        .replace(/\b(authorization|proxy-authorization)\s*([:=])\s*(?:Bearer\s+)?[^\s"',;]+/gi, "$1$2 Bearer ***")
+        // Cookie / Set-Cookie headers
+        .replace(/\b(cookie|set-cookie)\s*([:=])\s*[^"'\n]+/gi, "$1$2 ***")
+        // x-api-key, x-auth-token, and similar inline secrets
+        .replace(/((?:x-api-key|x-auth-token|api[_-]?key|api[_-]?token|access[_-]?token|refresh[_-]?token|token|secret|password|client[_-]?secret|private[-_]?key)\s*[:=]\s*)[^\s"',;]+/gi, "$1***"));
+}

package/dist/util/session.d.ts

@@ -0,0 +1,19 @@
+export declare function createOmkSessionId(prefix?: "chat" | "plan" | "run" | "team" | "session" | "feature" | "bugfix" | "refactor" | "review"): string;
+export declare function createOmkSessionEnv(projectRoot: string, sessionId: string): Record<string, string>;
+export interface SessionMeta {
+    runId: string;
+    type: "chat" | "plan" | "run" | "team" | "parallel";
+    status: "active" | "completed" | "failed" | "idle";
+    startedAt: string;
+    updatedAt: string;
+    endedAt?: string;
+    goalTitle?: string;
+    omkSessionId?: string;
+    kimiSessionId?: string;
+    todoCount: number;
+    todoDoneCount: number;
+}
+export declare function ensureSessionDir(runId: string): Promise<string>;
+export declare function writeSessionMeta(runId: string, meta: SessionMeta): Promise<void>;
+export declare function readSessionMeta(runId: string): Promise<SessionMeta | null>;
+export declare function listActiveSessions(): Promise<SessionMeta[]>;

package/dist/util/session.js

@@ -0,0 +1,80 @@
+import { writeFile, readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { getRunPath, getOmkPath, pathExists, ensureDir, validateRunId } from "./fs.js";
+export function createOmkSessionId(prefix = "session") {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return `${prefix}-${timestamp}-${process.pid}`;
+}
+export function createOmkSessionEnv(projectRoot, sessionId) {
+    return {
+        OMK_PROJECT_ROOT: projectRoot,
+        OMK_SESSION_ID: sessionId,
+    };
+}
+export async function ensureSessionDir(runId) {
+    const sanitized = validateRunId(runId);
+    const dir = getRunPath(sanitized);
+    await ensureDir(dir);
+    return dir;
+}
+export async function writeSessionMeta(runId, meta) {
+    const sanitized = validateRunId(runId);
+    const dir = await ensureSessionDir(sanitized);
+    const metaPath = join(dir, "session.json");
+    const payload = {
+        ...meta,
+        runId: sanitized,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeFile(metaPath, JSON.stringify(payload, null, 2), "utf-8");
+}
+export async function readSessionMeta(runId) {
+    const sanitized = validateRunId(runId);
+    const metaPath = join(getRunPath(sanitized), "session.json");
+    if (!(await pathExists(metaPath)))
+        return null;
+    try {
+        const content = await readFile(metaPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (!isSessionMeta(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function listActiveSessions() {
+    const runsDir = getOmkPath("runs");
+    if (!(await pathExists(runsDir)))
+        return [];
+    const entries = await readdir(runsDir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const meta = await readSessionMeta(entry.name).catch(() => null);
+        if (meta && meta.status === "active") {
+            results.push(meta);
+        }
+    }
+    return results.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+function isSessionMeta(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    return (typeof v.runId === "string" &&
+        typeof v.type === "string" &&
+        ["chat", "plan", "run", "team", "parallel"].includes(v.type) &&
+        typeof v.status === "string" &&
+        ["active", "completed", "failed", "idle"].includes(v.status) &&
+        typeof v.startedAt === "string" &&
+        typeof v.updatedAt === "string" &&
+        typeof v.todoCount === "number" &&
+        typeof v.todoDoneCount === "number" &&
+        (v.endedAt === undefined || typeof v.endedAt === "string") &&
+        (v.goalTitle === undefined || typeof v.goalTitle === "string") &&
+        (v.omkSessionId === undefined || typeof v.omkSessionId === "string") &&
+        (v.kimiSessionId === undefined || typeof v.kimiSessionId === "string"));
+}

package/dist/util/shell.d.ts

@@ -0,0 +1,30 @@
+export interface ShellResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    failed: boolean;
+}
+export interface StreamingShellOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    maxBuffer?: number;
+    stdio?: "pipe" | "inherit";
+    logPath?: string;
+    input?: string;
+    onStdout?: (line: string, io?: StreamingShellIo) => void;
+    onStderr?: (line: string, io?: StreamingShellIo) => void;
+    sudo?: boolean;
+    signal?: AbortSignal;
+    inheritEnv?: boolean;
+}
+export interface StreamingShellIo {
+    writeStdin(input: string): void;
+    terminate(reason?: string): void;
+}
+export declare function runShell(command: string, args?: string[], options?: StreamingShellOptions): Promise<ShellResult>;
+export declare function runShellStreaming(command: string, args?: string[], options?: StreamingShellOptions): Promise<ShellResult>;
+export declare function which(command: string): Promise<ShellResult>;
+export declare function checkCommand(command: string): Promise<boolean>;
+export declare function resolveKimiBin(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
+export declare function getKimiVersion(): Promise<string | null>;

package/dist/util/shell.js

@@ -0,0 +1,350 @@
+import { execa } from "execa";
+import { constants, createWriteStream } from "fs";
+import { access, appendFile, mkdir } from "fs/promises";
+import { dirname, isAbsolute } from "path";
+import { CappedOutputBuffer } from "./output-buffer.js";
+import { managedChildProcessOptions, terminateProcessTree } from "./process-tree.js";
+import { getOmkResourceSettings } from "./resource-profile.js";
+import { redactSecrets as redactSecretText } from "../mcp/secret-scanner.js";
+function isExecaError(err) {
+    return (typeof err === "object" &&
+        err !== null &&
+        ("stdout" in err || "stderr" in err || "exitCode" in err));
+}
+const SUDO_ALLOWLIST = new Set([
+    "docker",
+]);
+function applySudo(command, args, sudo) {
+    const useSudo = sudo === true || (sudo === undefined && process.env.OMK_SUDO === "1" && process.env.OMK_CLI_SUDO_REQUEST === "1");
+    if (!useSudo)
+        return [command, args];
+    if (!SUDO_ALLOWLIST.has(command)) {
+        throw new Error(`Command not in sudo allowlist: ${command}. Set sudo explicitly or add to allowlist.`);
+    }
+    return ["sudo", [command, ...args]];
+}
+const SAFE_INHERITED_ENV_NAMES = new Set([
+    "CI",
+    "COLORTERM",
+    "COMSPEC",
+    "FORCE_COLOR",
+    "HOME",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "NO_COLOR",
+    "OMK_ORIGINAL_HOME",
+    "OMK_PROJECT_ROOT",
+    "PATH",
+    "PATHEXT",
+    "SHELL",
+    "SystemRoot",
+    "TEMP",
+    "TERM",
+    "TMP",
+    "TMPDIR",
+    "USERPROFILE",
+    "WINDIR",
+]);
+function buildShellEnv(env, inheritEnv = false) {
+    const inherited = inheritEnv
+        ? process.env
+        : Object.fromEntries(Object.entries(process.env)
+            .filter(([name, value]) => value !== undefined && SAFE_INHERITED_ENV_NAMES.has(name)));
+    return { ...inherited, ...(env ?? {}) };
+}
+function redactShellText(text) {
+    return redactSecretText(text).redacted;
+}
+function shellTerminationMessage(reason, timeout) {
+    return reason === "timeout" ? `timed out after ${timeout ?? 0}ms` : "aborted";
+}
+function destroyProcessStreams(subprocess) {
+    const streams = subprocess;
+    try {
+        streams.stdout?.destroy(new Error("process tree terminated"));
+    }
+    catch {
+        // ignore stream cleanup failures
+    }
+    try {
+        streams.stderr?.destroy(new Error("process tree terminated"));
+    }
+    catch {
+        // ignore stream cleanup failures
+    }
+}
+function cleanupProcessTreeOnParentExit(subprocess) {
+    subprocess.once("exit", () => {
+        void terminateProcessTree(subprocess);
+    });
+}
+function createShellTerminator(subprocess, timeout, signal) {
+    let terminationReason;
+    let rejectTermination;
+    const termination = new Promise((_, reject) => {
+        rejectTermination = reject;
+    });
+    let terminationStarted;
+    const requestTermination = (reason) => {
+        if (!terminationReason)
+            terminationReason = reason;
+        if (!terminationStarted) {
+            destroyProcessStreams(subprocess);
+            terminationStarted = terminateProcessTree(subprocess);
+            void terminationStarted.finally(() => {
+                rejectTermination?.(new Error(terminationReason ?? reason));
+            });
+        }
+    };
+    const timeoutTimer = timeout > 0
+        ? setTimeout(() => {
+            requestTermination(shellTerminationMessage("timeout", timeout));
+        }, timeout)
+        : undefined;
+    timeoutTimer?.unref?.();
+    const abortHandler = () => {
+        requestTermination(shellTerminationMessage("abort"));
+    };
+    if (signal?.aborted)
+        abortHandler();
+    signal?.addEventListener("abort", abortHandler, { once: true });
+    return {
+        termination,
+        reason: () => terminationReason,
+        clear: () => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            signal?.removeEventListener("abort", abortHandler);
+        },
+    };
+}
+async function appendRedactedLog(logPath, stdout, stderr) {
+    if (!logPath)
+        return;
+    await mkdir(dirname(logPath), { recursive: true });
+    const chunks = [];
+    if (stdout)
+        chunks.push(redactShellText(stdout));
+    if (stderr)
+        chunks.push(redactShellText(stderr));
+    if (chunks.length > 0) {
+        await appendFile(logPath, chunks.join("\n"), "utf-8");
+    }
+}
+export async function runShell(command, args = [], options = {}) {
+    const resources = await getOmkResourceSettings();
+    const { cwd, env, timeout = 30000, maxBuffer = resources.shellMaxBufferBytes, stdio = "pipe", logPath, input, sudo, signal, inheritEnv } = options;
+    const [cmd, cmdArgs] = applySudo(command, args, sudo);
+    const subprocess = execa(cmd, cmdArgs, {
+        cwd,
+        env: buildShellEnv(env, inheritEnv),
+        extendEnv: false,
+        timeout: 0,
+        maxBuffer,
+        buffer: stdio !== "inherit",
+        stdio: stdio === "inherit" ? "inherit" : "pipe",
+        reject: false,
+        stripFinalNewline: false,
+        input,
+        ...managedChildProcessOptions(),
+    });
+    const terminator = createShellTerminator(subprocess, timeout, signal);
+    cleanupProcessTreeOnParentExit(subprocess);
+    try {
+        const result = await Promise.race([subprocess, terminator.termination]);
+        const stdout = redactShellText(String(result.stdout ?? ""));
+        const terminationReason = terminator.reason();
+        const stderr = redactShellText([
+            String(result.stderr ?? ""),
+            terminationReason,
+        ].filter(Boolean).join("\n"));
+        await appendRedactedLog(logPath, stdout, stderr);
+        return {
+            stdout,
+            stderr,
+            exitCode: result.exitCode ?? 1,
+            failed: terminationReason ? true : result.failed ?? result.exitCode !== 0,
+        };
+    }
+    catch (err) {
+        const terminationReason = terminator.reason();
+        if (isExecaError(err)) {
+            const stdout = redactShellText(String(err.stdout ?? ""));
+            const stderr = redactShellText([
+                String(err.stderr ?? "") || (err instanceof Error ? err.message : String(err)),
+                terminationReason,
+            ].filter(Boolean).join("\n"));
+            await appendRedactedLog(logPath, stdout, stderr);
+            return {
+                stdout,
+                stderr,
+                exitCode: err.exitCode ?? 1,
+                failed: true,
+            };
+        }
+        const stderr = redactShellText(terminationReason ?? (err instanceof Error ? err.message : String(err)));
+        await appendRedactedLog(logPath, "", stderr);
+        return {
+            stdout: "",
+            stderr,
+            exitCode: 1,
+            failed: true,
+        };
+    }
+    finally {
+        terminator.clear();
+    }
+}
+export async function runShellStreaming(command, args = [], options = {}) {
+    const resources = await getOmkResourceSettings();
+    const { cwd, env, timeout = 30000, maxBuffer = resources.shellMaxBufferBytes, stdio = "pipe", logPath, input, onStdout, onStderr, sudo, signal, inheritEnv } = options;
+    const [cmd, cmdArgs] = applySudo(command, args, sudo);
+    let logStream;
+    const stdoutBuffer = new CappedOutputBuffer(maxBuffer, "stdout");
+    const stderrBuffer = new CappedOutputBuffer(maxBuffer, "stderr");
+    // Set up log stream before spawning so data handlers can write to it
+    // immediately, avoiding any race between spawn and listener attachment.
+    if (logPath) {
+        await mkdir(dirname(logPath), { recursive: true });
+        logStream = createWriteStream(logPath, { flags: "a" });
+    }
+    const subprocess = execa(cmd, cmdArgs, {
+        cwd,
+        env: buildShellEnv(env, inheritEnv),
+        extendEnv: false,
+        timeout: 0,
+        buffer: false,
+        stdio: stdio === "inherit" ? "inherit" : "pipe",
+        reject: false,
+        stripFinalNewline: false,
+        input,
+        ...managedChildProcessOptions(),
+    });
+    const io = {
+        writeStdin(input) {
+            subprocess.stdin?.write(input);
+        },
+        terminate() {
+            void terminateProcessTree(subprocess);
+        },
+    };
+    // Attach data listeners IMMEDIATELY after execa() returns.
+    // Execa v9 with buffer:false schedules a setImmediate that calls
+    // resumeStream() if readableFlowing === null. If we yield to the event
+    // loop before attaching listeners (e.g. an await), that resumeStream()
+    // discards all stdout/stderr data because no consumer is present.
+    // By attaching synchronously here, readableFlowing becomes true before
+    // the setImmediate fires, so execa's internal resume is a no-op.
+    subprocess.stdout?.on("data", (chunk) => {
+        const line = chunk.toString("utf-8");
+        const redactedLine = redactShellText(line);
+        stdoutBuffer.append(redactedLine);
+        logStream?.write(redactedLine);
+        onStdout?.(redactedLine, io);
+    });
+    subprocess.stderr?.on("data", (chunk) => {
+        const line = chunk.toString("utf-8");
+        const redactedLine = redactShellText(line);
+        stderrBuffer.append(redactedLine);
+        logStream?.write(redactedLine);
+        onStderr?.(redactedLine, io);
+    });
+    const terminator = createShellTerminator(subprocess, timeout, signal);
+    cleanupProcessTreeOnParentExit(subprocess);
+    try {
+        const result = await Promise.race([subprocess, terminator.termination]);
+        // Execa v9 resolves on the 'exit' event, which can fire before stdio
+        // streams have fully drained. Yield to the event loop so any pending
+        // 'data' events on stdout/stderr are processed before we read the buffers.
+        await new Promise((resolve) => setImmediate(resolve));
+        const terminationReason = terminator.reason();
+        if (terminationReason)
+            stderrBuffer.append(`\n${terminationReason}`);
+        return {
+            stdout: stdoutBuffer.toString(),
+            stderr: stderrBuffer.toString(),
+            exitCode: result.exitCode ?? 1,
+            failed: terminationReason ? true : result.failed ?? result.exitCode !== 0,
+        };
+    }
+    catch (err) {
+        await new Promise((resolve) => setImmediate(resolve)).catch(() => { });
+        const terminationReason = terminator.reason();
+        if (isExecaError(err)) {
+            return {
+                stdout: stdoutBuffer.toString() || redactShellText(String(err.stdout ?? "")),
+                stderr: [
+                    stderrBuffer.toString() || redactShellText(String(err.stderr ?? "") || (err instanceof Error ? err.message : String(err))),
+                    terminationReason,
+                ].filter(Boolean).join("\n"),
+                exitCode: err.exitCode ?? 1,
+                failed: true,
+            };
+        }
+        const stderr = redactShellText(terminationReason ?? (err instanceof Error ? err.message : String(err)));
+        return {
+            stdout: "",
+            stderr,
+            exitCode: 1,
+            failed: true,
+        };
+    }
+    finally {
+        terminator.clear();
+        logStream?.end();
+    }
+}
+function okShellResult(stdout) {
+    return { stdout, stderr: "", exitCode: 0, failed: false };
+}
+function failedShellResult(stderr) {
+    return { stdout: "", stderr, exitCode: 1, failed: true };
+}
+function includesPathSeparator(command) {
+    return command.includes("/") || command.includes("\\");
+}
+async function commandPathExists(command) {
+    try {
+        await access(command, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function which(command) {
+    if (isAbsolute(command) || includesPathSeparator(command)) {
+        return await commandPathExists(command)
+            ? okShellResult(command)
+            : failedShellResult(`command not found: ${command}`);
+    }
+    const isWindows = process.platform === "win32";
+    return isWindows
+        ? runShell("where.exe", [command], { timeout: 5000 })
+        : runShell("which", [command], { timeout: 5000 });
+}
+export async function checkCommand(command) {
+    try {
+        if (isAbsolute(command) || includesPathSeparator(command)) {
+            return await commandPathExists(command);
+        }
+        const isWindows = process.platform === "win32";
+        const result = isWindows
+            ? await runShell("where.exe", [command], { timeout: 5000 })
+            : await runShell("sh", ["-c", 'command -v "$1"', "sh", command], { timeout: 5000 });
+        return !result.failed && result.stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveKimiBin(env = process.env) {
+    return env.KIMI_BIN ?? "kimi";
+}
+export async function getKimiVersion() {
+    const result = await runShell(resolveKimiBin(), ["--version"], { timeout: 10000 });
+    if (result.failed)
+        return null;
+    return result.stdout.trim();
+}

package/dist/util/snippet.d.ts

@@ -0,0 +1,17 @@
+export interface Snippet {
+    name: string;
+    content: string;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function saveSnippet(name: string, content: string, tags?: string[]): Promise<{
+    success: boolean;
+    path: string;
+}>;
+export declare function getSnippet(name: string): Promise<Snippet | null>;
+export declare function deleteSnippet(name: string): Promise<{
+    success: boolean;
+}>;
+export declare function searchSnippets(query: string, limit?: number): Promise<Snippet[]>;
+export declare function listSnippets(): Promise<Snippet[]>;

package/dist/util/snippet.js

@@ -0,0 +1,110 @@
+import { mkdir, readdir, writeFile, rm } from "fs/promises";
+import { join } from "path";
+import { getProjectRoot, pathExists, readTextFile } from "./fs.js";
+const SNIPPETS_DIR = ".omk/snippets";
+function getSnippetsPath() {
+    return join(getProjectRoot(), SNIPPETS_DIR);
+}
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9_-]/g, "_").substring(0, 128);
+}
+function parseSnippetFile(content, name) {
+    const lines = content.split("\n");
+    const meta = {};
+    let bodyStart = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith("<!-- ") && line.endsWith(" -->")) {
+            const inner = line.slice(5, -4).trim();
+            const eq = inner.indexOf("=");
+            if (eq > 0) {
+                meta[inner.slice(0, eq).trim()] = inner.slice(eq + 1).trim();
+            }
+            bodyStart = i + 1;
+        }
+        else if (line.trim() === "---") {
+            bodyStart = i + 1;
+            break;
+        }
+        else if (line.trim() !== "" && !line.startsWith("<!--")) {
+            break;
+        }
+        else {
+            bodyStart = i + 1;
+        }
+    }
+    const body = lines.slice(bodyStart).join("\n").trim();
+    const now = new Date().toISOString();
+    return {
+        name,
+        content: body,
+        tags: meta.tags ? meta.tags.split(",").map((t) => t.trim()).filter(Boolean) : [],
+        createdAt: meta.createdAt || now,
+        updatedAt: meta.updatedAt || now,
+    };
+}
+function serializeSnippet(snippet) {
+    const tagsLine = snippet.tags.length > 0 ? `<!-- tags=${snippet.tags.join(",")} -->` : "";
+    const createdLine = `<!-- createdAt=${snippet.createdAt} -->`;
+    const updatedLine = `<!-- updatedAt=${snippet.updatedAt} -->`;
+    return [tagsLine, createdLine, updatedLine, "", snippet.content].filter((l) => l !== undefined).join("\n");
+}
+export async function saveSnippet(name, content, tags) {
+    const safeName = sanitizeName(name);
+    const dir = getSnippetsPath();
+    await mkdir(dir, { recursive: true });
+    const filePath = join(dir, `${safeName}.md`);
+    const now = new Date().toISOString();
+    const snippet = {
+        name: safeName,
+        content,
+        tags: tags ?? [],
+        createdAt: now,
+        updatedAt: now,
+    };
+    await writeFile(filePath, serializeSnippet(snippet), "utf-8");
+    return { success: true, path: filePath };
+}
+export async function getSnippet(name) {
+    const safeName = sanitizeName(name);
+    const filePath = join(getSnippetsPath(), `${safeName}.md`);
+    if (!(await pathExists(filePath)))
+        return null;
+    const content = await readTextFile(filePath, "");
+    if (!content.trim())
+        return null;
+    return parseSnippetFile(content, safeName);
+}
+export async function deleteSnippet(name) {
+    const safeName = sanitizeName(name);
+    const filePath = join(getSnippetsPath(), `${safeName}.md`);
+    if (!(await pathExists(filePath)))
+        return { success: false };
+    await rm(filePath);
+    return { success: true };
+}
+export async function searchSnippets(query, limit = 20) {
+    const dir = getSnippetsPath();
+    if (!(await pathExists(dir)))
+        return [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        const name = entry.name.slice(0, -3);
+        const content = await readTextFile(join(dir, entry.name), "");
+        if (!content.trim())
+            continue;
+        const snippet = parseSnippetFile(content, name);
+        const text = `${snippet.name} ${snippet.content} ${snippet.tags.join(" ")}`.toLowerCase();
+        if (!lowerQuery || text.includes(lowerQuery)) {
+            results.push(snippet);
+        }
+    }
+    return results.slice(0, limit);
+}
+export async function listSnippets() {
+    return searchSnippets("", 1000);
+}

package/dist/util/sync-manifest.d.ts

@@ -0,0 +1,13 @@
+export type SyncScope = "global" | "local";
+export type SyncAction = "create" | "update" | "delete" | "symlink" | "blocked";
+export interface SyncManifestEntry {
+    path: string;
+    scope: SyncScope;
+    action: SyncAction;
+    previousHash: string | null;
+    newHash: string | null;
+    backupPath: string | null;
+    timestamp: string;
+}
+export declare function sha256(content: string): string;
+export declare function simpleDiff(oldText: string, newText: string): string;