myagentmemory 0.4.12 → 0.4.14

package/dist/hooks.js

@@ -0,0 +1,444 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+let homeDirOverride = null;
+/** Override the detected home directory in deterministic tests. */
+export function _setHookHomeDirForTest(directory) {
+    homeDirOverride = directory;
+}
+function resolveHomeDir() {
+    if (homeDirOverride !== null)
+        return homeDirOverride;
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+    return home && home !== "~" ? home : null;
+}
+function commandExists(command) {
+    const envPath = process.env.PATH ?? "";
+    if (!envPath)
+        return false;
+    const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean) : [""];
+    for (const directory of envPath.split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const filename = process.platform === "win32" ? `${command}${extension}` : command;
+            try {
+                fs.accessSync(path.join(directory, filename), fs.constants.X_OK);
+                return true;
+            }
+            catch { }
+        }
+    }
+    return false;
+}
+const HOOK_MARKER_JSON = "_agentMemory";
+const HOOK_MARKER_BEGIN = "# BEGIN agent-memory hook";
+const HOOK_MARKER_END = "# END agent-memory hook";
+function sessionStartHookCommand(agent) {
+    return `agent-memory hook session-start --agent ${agent}`;
+}
+function hookTargets(homeDir) {
+    return [
+        {
+            key: "claude",
+            label: "Claude Code",
+            homeMarker: path.join(homeDir, ".claude"),
+            detectFiles: [
+                path.join(homeDir, ".claude", "settings.json"),
+                path.join(homeDir, ".claude", "settings.local.json"),
+            ],
+            detectCommand: "claude",
+            supported: true,
+        },
+        {
+            key: "codex",
+            label: "Codex",
+            homeMarker: path.join(homeDir, ".codex"),
+            detectFiles: [path.join(homeDir, ".codex", "config.toml")],
+            detectCommand: "codex",
+            supported: true,
+        },
+        {
+            key: "cursor",
+            label: "Cursor",
+            homeMarker: path.join(homeDir, ".cursor"),
+            detectFiles: [],
+            supported: true,
+        },
+        {
+            key: "opencode",
+            label: "opencode",
+            homeMarker: path.join(homeDir, ".config", "opencode"),
+            detectFiles: [path.join(homeDir, ".config", "opencode", "opencode.json")],
+            detectCommand: "opencode",
+            supported: true,
+        },
+        {
+            key: "pi",
+            label: "pi",
+            homeMarker: path.join(homeDir, ".pi"),
+            detectFiles: [],
+            detectCommand: "pi",
+            supported: false,
+            unsupportedReason: "no documented SessionStart hook mechanism",
+        },
+    ];
+}
+export function detectHookAgents() {
+    const homeDir = resolveHomeDir();
+    if (!homeDir)
+        return { homeDir: null, targets: [] };
+    const targets = hookTargets(homeDir).map((target) => {
+        if (!fs.existsSync(target.homeMarker)) {
+            return { ...target, detected: false, detectReason: `${target.homeMarker} not found` };
+        }
+        const byFile = target.detectFiles.some((f) => fs.existsSync(f));
+        const byCommand = target.detectCommand ? commandExists(target.detectCommand) : false;
+        const requires = target.detectFiles.length > 0 || !!target.detectCommand;
+        if (requires && !byFile && !byCommand) {
+            return { ...target, detected: false, detectReason: "not detected" };
+        }
+        return { ...target, detected: true };
+    });
+    return { homeDir, targets };
+}
+function backupOnce(filePath) {
+    if (!fs.existsSync(filePath))
+        return undefined;
+    const backupPath = `${filePath}.agent-memory.bak`;
+    if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(filePath, backupPath);
+    }
+    return backupPath;
+}
+function readJsonConfig(filePath) {
+    if (!fs.existsSync(filePath))
+        return {};
+    let parsed;
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        parsed = raw.trim() ? JSON.parse(raw) : {};
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`cannot modify invalid JSON config ${filePath}: ${detail}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`cannot modify JSON config ${filePath}: root value must be an object`);
+    }
+    return parsed;
+}
+function writeJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+}
+function installClaudeCodeHook(homeDir) {
+    const settingsPath = path.join(homeDir, ".claude", "settings.json");
+    const backup = backupOnce(settingsPath);
+    const settings = readJsonConfig(settingsPath);
+    const hooks = settings.hooks ?? {};
+    const sessionStart = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
+    // Idempotency: look for any existing entry tagged with our marker.
+    const command = sessionStartHookCommand("claude");
+    let managed = 0;
+    let updated = 0;
+    for (const group of sessionStart) {
+        if (!group || typeof group !== "object")
+            continue;
+        const g = group;
+        const list = Array.isArray(g.hooks) ? g.hooks : [];
+        for (const hook of list) {
+            if (!hook || typeof hook !== "object")
+                continue;
+            const managedHook = hook;
+            if (managedHook[HOOK_MARKER_JSON] !== true)
+                continue;
+            managed++;
+            if (managedHook.command !== command) {
+                managedHook.command = command;
+                updated++;
+            }
+        }
+    }
+    if (managed && !updated) {
+        return { key: "claude", label: "Claude Code", installed: false, path: settingsPath, reason: "already installed" };
+    }
+    if (updated) {
+        hooks.SessionStart = sessionStart;
+        settings.hooks = hooks;
+        writeJson(settingsPath, settings);
+        return { key: "claude", label: "Claude Code", installed: true, path: settingsPath, backup, reason: "updated" };
+    }
+    sessionStart.push({
+        matcher: "startup|resume",
+        hooks: [{ type: "command", command, [HOOK_MARKER_JSON]: true }],
+    });
+    hooks.SessionStart = sessionStart;
+    settings.hooks = hooks;
+    writeJson(settingsPath, settings);
+    return { key: "claude", label: "Claude Code", installed: true, path: settingsPath, backup };
+}
+function installCodexHook(homeDir) {
+    const configPath = path.join(homeDir, ".codex", "config.toml");
+    const backup = backupOnce(configPath);
+    const existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf-8") : "";
+    const command = sessionStartHookCommand("codex");
+    const block = [
+        HOOK_MARKER_BEGIN,
+        "[[hooks.SessionStart]]",
+        'matcher = "startup|resume"',
+        "",
+        "[[hooks.SessionStart.hooks]]",
+        'type = "command"',
+        `command = "${command}"`,
+        HOOK_MARKER_END,
+    ].join("\n");
+    if (existing.includes(HOOK_MARKER_BEGIN)) {
+        const escapeRe = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const pattern = new RegExp(`${escapeRe(HOOK_MARKER_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_MARKER_END)}`);
+        const current = existing.match(pattern)?.[0] ?? "";
+        if (current.includes(`command = "${command}"`)) {
+            return { key: "codex", label: "Codex", installed: false, path: configPath, reason: "already installed" };
+        }
+        fs.writeFileSync(configPath, existing.replace(pattern, block), "utf-8");
+        return { key: "codex", label: "Codex", installed: true, path: configPath, backup, reason: "updated" };
+    }
+    const separator = existing === "" || existing.endsWith("\n") ? "" : "\n";
+    const next = `${existing}${separator}${block}\n`;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, next, "utf-8");
+    return { key: "codex", label: "Codex", installed: true, path: configPath, backup };
+}
+const CURSOR_RULE_BODY = `---
+description: Load persistent memory context from agent-memory
+alwaysApply: true
+---
+
+At the start of every conversation, and whenever the user references prior
+context, run:
+
+    agent-memory context
+
+Treat its stdout as authoritative context about the user, prior sessions,
+scratchpad items, and long-term memory. Prefer it over guessing.
+`;
+function installCursorRule(homeDir) {
+    const rulesDir = path.join(homeDir, ".cursor", "rules");
+    const rulePath = path.join(rulesDir, "agent-memory.mdc");
+    if (fs.existsSync(rulePath)) {
+        return { key: "cursor", label: "Cursor", installed: false, path: rulePath, reason: "already installed" };
+    }
+    fs.mkdirSync(rulesDir, { recursive: true });
+    fs.writeFileSync(rulePath, CURSOR_RULE_BODY, "utf-8");
+    return { key: "cursor", label: "Cursor", installed: true, path: rulePath };
+}
+const OPENCODE_INSTRUCTIONS_BODY = `# agent-memory
+
+At the start of every session and before answering context-dependent
+questions, run:
+
+    agent-memory context
+
+Treat its stdout as authoritative context about the user, prior sessions,
+scratchpad items, and long-term memory.
+`;
+function installOpencodeInstructions(homeDir) {
+    const configPath = path.join(homeDir, ".config", "opencode", "opencode.json");
+    const instructionsPath = path.join(homeDir, ".agent-memory", "hooks", "opencode.md");
+    const backup = backupOnce(configPath);
+    const config = readJsonConfig(configPath);
+    const raw = config.instructions;
+    const list = Array.isArray(raw) ? [...raw] : [];
+    if (list.includes(instructionsPath)) {
+        return { key: "opencode", label: "opencode", installed: false, path: configPath, reason: "already installed" };
+    }
+    list.push(instructionsPath);
+    config.instructions = list;
+    fs.mkdirSync(path.dirname(instructionsPath), { recursive: true });
+    fs.writeFileSync(instructionsPath, OPENCODE_INSTRUCTIONS_BODY, "utf-8");
+    writeJson(configPath, config);
+    return { key: "opencode", label: "opencode", installed: true, path: configPath, backup };
+}
+export function installHooks(agents) {
+    const { homeDir, targets } = detectHookAgents();
+    if (!homeDir) {
+        return {
+            ok: false,
+            results: [],
+            error: "Home directory not found. Set HOME (or USERPROFILE on Windows) and retry.",
+        };
+    }
+    const results = [];
+    for (const target of targets) {
+        if (!agents.has(target.key))
+            continue;
+        if (!target.supported) {
+            results.push({
+                key: target.key,
+                label: target.label,
+                installed: false,
+                reason: target.unsupportedReason ?? "not supported",
+            });
+            continue;
+        }
+        if (!target.detected) {
+            results.push({
+                key: target.key,
+                label: target.label,
+                installed: false,
+                reason: target.detectReason ?? "not detected",
+            });
+            continue;
+        }
+        try {
+            if (target.key === "claude")
+                results.push(installClaudeCodeHook(homeDir));
+            else if (target.key === "codex")
+                results.push(installCodexHook(homeDir));
+            else if (target.key === "cursor")
+                results.push(installCursorRule(homeDir));
+            else if (target.key === "opencode")
+                results.push(installOpencodeInstructions(homeDir));
+        }
+        catch (err) {
+            results.push({
+                key: target.key,
+                label: target.label,
+                installed: false,
+                reason: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return { ok: true, homeDir, results };
+}
+function uninstallClaudeCodeHook(homeDir) {
+    const settingsPath = path.join(homeDir, ".claude", "settings.json");
+    if (!fs.existsSync(settingsPath)) {
+        return { key: "claude", label: "Claude Code", installed: false, reason: "not installed" };
+    }
+    const settings = readJsonConfig(settingsPath);
+    const hooks = settings.hooks ?? {};
+    const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    let removed = 0;
+    const filtered = sessionStart
+        .map((group) => {
+        if (!group || typeof group !== "object")
+            return group;
+        const g = { ...group };
+        const list = Array.isArray(g.hooks) ? g.hooks : [];
+        const kept = list.filter((h) => {
+            const isOurs = h && typeof h === "object" && h[HOOK_MARKER_JSON] === true;
+            if (isOurs)
+                removed++;
+            return !isOurs;
+        });
+        g.hooks = kept;
+        return g;
+    })
+        .filter((group) => {
+        if (!group || typeof group !== "object")
+            return true;
+        const g = group;
+        return Array.isArray(g.hooks) && g.hooks.length > 0;
+    });
+    if (removed === 0) {
+        return { key: "claude", label: "Claude Code", installed: false, reason: "not installed" };
+    }
+    hooks.SessionStart = filtered;
+    if (filtered.length === 0)
+        delete hooks.SessionStart;
+    if (Object.keys(hooks).length === 0)
+        delete settings.hooks;
+    else
+        settings.hooks = hooks;
+    writeJson(settingsPath, settings);
+    return { key: "claude", label: "Claude Code", installed: true, path: settingsPath };
+}
+function uninstallCodexHook(homeDir) {
+    const configPath = path.join(homeDir, ".codex", "config.toml");
+    if (!fs.existsSync(configPath)) {
+        return { key: "codex", label: "Codex", installed: false, reason: "not installed" };
+    }
+    const existing = fs.readFileSync(configPath, "utf-8");
+    if (!existing.includes(HOOK_MARKER_BEGIN)) {
+        return { key: "codex", label: "Codex", installed: false, reason: "not installed" };
+    }
+    const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`\\n?${escapeRe(HOOK_MARKER_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_MARKER_END)}\\n?`, "g");
+    const next = existing.replace(pattern, "");
+    fs.writeFileSync(configPath, next, "utf-8");
+    return { key: "codex", label: "Codex", installed: true, path: configPath };
+}
+function uninstallCursorRule(homeDir) {
+    const rulePath = path.join(homeDir, ".cursor", "rules", "agent-memory.mdc");
+    if (!fs.existsSync(rulePath)) {
+        return { key: "cursor", label: "Cursor", installed: false, reason: "not installed" };
+    }
+    fs.unlinkSync(rulePath);
+    try {
+        fs.rmdirSync(path.dirname(rulePath));
+    }
+    catch {
+        // non-empty; fine
+    }
+    return { key: "cursor", label: "Cursor", installed: true, path: rulePath };
+}
+function uninstallOpencodeInstructions(homeDir) {
+    const configPath = path.join(homeDir, ".config", "opencode", "opencode.json");
+    const instructionsPath = path.join(homeDir, ".agent-memory", "hooks", "opencode.md");
+    let touched = false;
+    if (fs.existsSync(configPath)) {
+        const config = readJsonConfig(configPath);
+        const list = Array.isArray(config.instructions) ? config.instructions : [];
+        const filtered = list.filter((entry) => entry !== instructionsPath);
+        if (filtered.length !== list.length) {
+            touched = true;
+            if (filtered.length === 0)
+                delete config.instructions;
+            else
+                config.instructions = filtered;
+            writeJson(configPath, config);
+        }
+    }
+    if (fs.existsSync(instructionsPath)) {
+        fs.unlinkSync(instructionsPath);
+        touched = true;
+    }
+    if (!touched) {
+        return { key: "opencode", label: "opencode", installed: false, reason: "not installed" };
+    }
+    return { key: "opencode", label: "opencode", installed: true, path: configPath };
+}
+export function uninstallHooks(agents) {
+    const homeDir = resolveHomeDir();
+    if (!homeDir) {
+        return {
+            ok: false,
+            results: [],
+            error: "Home directory not found. Set HOME (or USERPROFILE on Windows) and retry.",
+        };
+    }
+    const keys = ["claude", "codex", "cursor", "opencode"];
+    const results = [];
+    for (const key of keys) {
+        if (agents && !agents.has(key))
+            continue;
+        try {
+            if (key === "claude")
+                results.push(uninstallClaudeCodeHook(homeDir));
+            else if (key === "codex")
+                results.push(uninstallCodexHook(homeDir));
+            else if (key === "cursor")
+                results.push(uninstallCursorRule(homeDir));
+            else if (key === "opencode")
+                results.push(uninstallOpencodeInstructions(homeDir));
+        }
+        catch (err) {
+            results.push({
+                key,
+                label: key,
+                installed: false,
+                reason: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return { ok: true, homeDir, results };
+}

package/dist/plugin-bootstrap.d.ts

@@ -0,0 +1,190 @@
+import { type AgentMemoryBundleManifestV1, type PluginEntitlementStatusV1 } from "./plugin-host.js";
+export declare const OFFICIAL_BUNDLE_ID = "agentmemory.pro";
+export declare const OFFICIAL_PLUGIN_IDS: readonly ["agentmemory.session-intelligence", "agentmemory.web-console"];
+export type PluginBootstrapResultKindV1 = "not_installed" | "installed" | "upgraded" | "current" | "update_available" | "uninstalled" | "auth_required" | "renewal_required" | "unavailable";
+export interface PluginBootstrapErrorV1 {
+    code: string;
+    message: string;
+    retryable?: boolean;
+}
+export interface PluginNextActionV1 {
+    kind: "authenticate" | "renew" | "manage";
+    url: string;
+    userCode?: string;
+    message?: string;
+}
+export interface PluginInstallReceiptV1 {
+    schemaVersion: 1;
+    bundleId: string;
+    version: string;
+    channel: string;
+    pluginApi: 1;
+    entrypoint: string;
+    packageSha256: string;
+    installedAt: string;
+    previousVersion?: string;
+}
+export interface PluginSummaryV1 {
+    id: string;
+    name: string;
+    installed: boolean;
+    available: boolean;
+    entitlement: PluginEntitlementStatusV1["state"];
+}
+export interface PluginBootstrapResultV1 {
+    schemaVersion: 1;
+    command: `plugin.${string}`;
+    ok: boolean;
+    result: PluginBootstrapResultKindV1;
+    bundle: {
+        id: string;
+        previousVersion: string | null;
+        version: string | null;
+        channel: string;
+    } | null;
+    entitlement: PluginEntitlementStatusV1;
+    plugins?: PluginSummaryV1[];
+    nextAction: PluginNextActionV1 | null;
+    error?: PluginBootstrapErrorV1;
+}
+export interface SignedPluginReleaseV1 {
+    schemaVersion: 1;
+    manifest: AgentMemoryBundleManifestV1;
+    platform: string;
+    architecture: string;
+    packageSha256: string;
+    size: number;
+    signature: {
+        algorithm: "ed25519";
+        keyId: string;
+        value: string;
+    };
+}
+export interface AgentMemoryPackageFileV1 {
+    path: string;
+    sha256: string;
+    contentBase64: string;
+    executable?: boolean;
+}
+export interface AgentMemoryPackageV1 {
+    schemaVersion: 1;
+    manifest: AgentMemoryBundleManifestV1;
+    files: AgentMemoryPackageFileV1[];
+}
+export type PluginAccessDecisionV1 = {
+    kind: "granted";
+    entitlement: PluginEntitlementStatusV1;
+    artifactGrant: string;
+} | {
+    kind: "auth_required";
+    entitlement: PluginEntitlementStatusV1;
+    nextAction: PluginNextActionV1;
+} | {
+    kind: "renewal_required";
+    entitlement: PluginEntitlementStatusV1;
+    nextAction: PluginNextActionV1;
+} | {
+    kind: "unavailable";
+    entitlement: PluginEntitlementStatusV1;
+    error: PluginBootstrapErrorV1;
+};
+export interface PluginBootstrapBackendV1 {
+    getLocalEntitlement(): Promise<PluginEntitlementStatusV1>;
+    resolveAccess(request: {
+        bundleId: string;
+        installedVersion?: string;
+        channel: string;
+        allowAuthentication: boolean;
+    }): Promise<PluginAccessDecisionV1>;
+    listReleases(request: {
+        bundleId: string;
+        channel: string;
+        artifactGrant: string;
+    }): Promise<SignedPluginReleaseV1[]>;
+    downloadArtifact(request: {
+        release: SignedPluginReleaseV1;
+        artifactGrant: string;
+    }): Promise<Uint8Array>;
+    getManagementAction(): Promise<PluginNextActionV1 | null>;
+}
+export interface PluginReleaseVerifierV1 {
+    verifyRelease(release: SignedPluginReleaseV1): void;
+}
+export interface PluginInstallStoreV1 {
+    readonly root: string;
+    readReceipt(bundleId: string): PluginInstallReceiptV1 | null;
+    hasInstalledBundle(receipt: PluginInstallReceiptV1): boolean;
+    install(packageBytes: Uint8Array, release: SignedPluginReleaseV1, healthCheck?: (directory: string, release: SignedPluginReleaseV1) => Promise<void>): Promise<PluginInstallReceiptV1>;
+    uninstall(bundleId: string): PluginInstallReceiptV1 | null;
+}
+export interface PluginBootstrapOptionsV1 {
+    coreVersion: string;
+    backend: PluginBootstrapBackendV1;
+    verifier: PluginReleaseVerifierV1;
+    store: PluginInstallStoreV1;
+    platform?: string;
+    architecture?: string;
+    healthCheck?: (directory: string, release: SignedPluginReleaseV1) => Promise<void>;
+}
+export interface PluginReconcileOptionsV1 {
+    channel?: string;
+    allowAuthentication?: boolean;
+}
+export declare class PluginBootstrapFailure extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(code: string, message: string, retryable?: boolean);
+}
+export declare class UnavailablePluginBackend implements PluginBootstrapBackendV1 {
+    getLocalEntitlement(): Promise<PluginEntitlementStatusV1>;
+    resolveAccess(): Promise<PluginAccessDecisionV1>;
+    listReleases(): Promise<SignedPluginReleaseV1[]>;
+    downloadArtifact(): Promise<Uint8Array>;
+    getManagementAction(): Promise<PluginNextActionV1 | null>;
+}
+export declare class RejectingReleaseVerifier implements PluginReleaseVerifierV1 {
+    verifyRelease(): void;
+}
+export declare class Ed25519ReleaseVerifier implements PluginReleaseVerifierV1 {
+    private readonly keys;
+    constructor(keys: Record<string, string | Buffer>);
+    verifyRelease(release: SignedPluginReleaseV1): void;
+}
+export declare class FilePluginInstallStore implements PluginInstallStoreV1 {
+    readonly root: string;
+    constructor(root?: string);
+    readReceipt(bundleId: string): PluginInstallReceiptV1 | null;
+    hasInstalledBundle(receipt: PluginInstallReceiptV1): boolean;
+    install(packageBytes: Uint8Array, release: SignedPluginReleaseV1, healthCheck?: (directory: string, release: SignedPluginReleaseV1) => Promise<void>): Promise<PluginInstallReceiptV1>;
+    uninstall(bundleId: string): PluginInstallReceiptV1 | null;
+    private ensureRoot;
+    private receiptPath;
+    private versionPath;
+    private writeReceipt;
+    private acquireLock;
+    private releaseLock;
+}
+export declare class PluginBootstrapV1 {
+    private readonly options;
+    private readonly platform;
+    private readonly architecture;
+    constructor(options: PluginBootstrapOptionsV1);
+    list(): Promise<PluginBootstrapResultV1>;
+    status(channel?: string): Promise<PluginBootstrapResultV1>;
+    install(options?: PluginReconcileOptionsV1): Promise<PluginBootstrapResultV1>;
+    update(options?: PluginReconcileOptionsV1): Promise<PluginBootstrapResultV1>;
+    uninstall(): Promise<PluginBootstrapResultV1>;
+    manage(): Promise<PluginBootstrapResultV1>;
+    private reconcile;
+    private selectRelease;
+    private validReceipt;
+    private result;
+    private failure;
+}
+export declare function createDefaultPluginBootstrap(coreVersion: string): PluginBootstrapV1;
+export declare function getDefaultPluginInstallRoot(): string;
+export declare function encodePluginPackage(packageValue: AgentMemoryPackageV1): Uint8Array;
+export declare function releaseSigningPayload(release: SignedPluginReleaseV1): Uint8Array;
+export declare function sha256(value: Uint8Array): string;
+export declare function compareVersions(left: string, right: string): number;
+export declare function supportsVersionRange(range: string, version: string): boolean;