@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/plugin-package.js

@@ -0,0 +1,553 @@
+/**
+ * Static plugin-package materialization and inspection.
+ *
+ * This module deliberately never imports a plugin entry point. Package code is
+ * copied/downloaded with lifecycle scripts disabled, then only package.json and
+ * the referenced JSON manifest are parsed.
+ */
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { create as createTar } from "tar";
+import { parsePluginManifest, } from "@rynx-ai/plugin-sdk";
+const MAX_METADATA_BYTES = 1024 * 1024;
+/** Classify provenance without fetching or executing anything. */
+export function detectPluginSource(spec) {
+    if (looksLocal(spec))
+        return "local";
+    if (/^(?:git\+|git:|git@|ssh:|github:|gitlab:|bitbucket:)/i.test(spec) ||
+        /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:#.*)?$/.test(spec)) {
+        return "git";
+    }
+    if (/^https?:\/\//i.test(spec))
+        return spec.includes(".git") ? "git" : "url";
+    return "npm";
+}
+/** Stable provenance for local sources; remote specs are retained verbatim. */
+export function normalizePluginSpec(spec, source) {
+    return source === "local" ? toLocalDir(spec) : spec;
+}
+/**
+ * Materialize a package without running package lifecycle scripts.
+ *
+ * Local workspace packages are archived with their internal dependency closure
+ * and then installed into a disposable npm prefix. Other local, npm, git, and
+ * URL specs use the same prefix flow. Every path therefore reaches inspection
+ * with runtime dependencies present, while lifecycle scripts remain disabled.
+ */
+export const materializePluginPackage = async ({ spec, source, destination, onProgress, signal, }) => {
+    if (source === "local") {
+        await materializeLocalDirectory(toLocalDir(spec), destination, onProgress, signal);
+        return;
+    }
+    if (source === "git") {
+        const checkout = join(resolve(destination, ".."), "git-checkout");
+        await cloneGitPackage(spec, checkout, onProgress, signal);
+        await materializeLocalDirectory(checkout, destination, onProgress, signal);
+        return;
+    }
+    const archive = await acquirePublishedPackageArchive(spec, join(resolve(destination, ".."), "package-archive"), onProgress, signal);
+    await materializeWithNpm({
+        spec: archive,
+        prefix: join(resolve(destination, ".."), "remote-prefix"),
+        destination,
+        onProgress,
+        signal,
+    });
+};
+async function materializeLocalDirectory(sourceDir, destination, onProgress, signal) {
+    if (!existsSync(sourceDir) || !statSync(sourceDir).isDirectory()) {
+        throw new Error(`local plugin source is not a directory: ${sourceDir}`);
+    }
+    const sourceReal = realpathSync(sourceDir);
+    if (isWithin(sourceReal, resolve(destination))) {
+        throw new Error("plugin staging directory must not be inside the local source");
+    }
+    if (!hasProductionDependencies(sourceReal)) {
+        copyPackageTree(sourceReal, destination, true);
+        onProgress(`copied self-contained local plugin package from ${sourceReal}`);
+        return;
+    }
+    const workspaceRoot = findPnpmWorkspaceRoot(sourceReal);
+    if (workspaceRoot) {
+        const stagedWorkspace = await stageLocalWorkspaceClosure(sourceReal, workspaceRoot, join(resolve(destination, ".."), "workspace-packages"));
+        onProgress(`materializing local workspace plugin with ${stagedWorkspace.packageCount - 1} workspace dependency/dependencies`);
+        await materializeWithNpm({
+            spec: stagedWorkspace.pluginArchive,
+            prefix: join(resolve(destination, ".."), "local-prefix"),
+            destination,
+            onProgress,
+            signal,
+            label: "local workspace",
+        });
+        // The rewritten file: specs are a staging-only resolution aid. Keep the
+        // installed plugin's own package metadata identical to its source.
+        writeFileSync(join(destination, "package.json"), readFileSync(join(sourceReal, "package.json")));
+        return;
+    }
+    const localArchiveRoot = join(resolve(destination, ".."), "local-package");
+    const localPackage = join(localArchiveRoot, "package");
+    rmSync(localArchiveRoot, { recursive: true, force: true });
+    copyPackageTree(sourceReal, localPackage, true);
+    const localArchive = join(localArchiveRoot, "package.tgz");
+    await createPackageArchive(localPackage, localArchive);
+    await materializeWithNpm({
+        spec: localArchive,
+        prefix: join(resolve(destination, ".."), "local-prefix"),
+        destination,
+        onProgress,
+        signal,
+        label: "local",
+    });
+}
+async function acquirePublishedPackageArchive(spec, archiveRoot, onProgress, signal) {
+    rmSync(archiveRoot, { recursive: true, force: true });
+    mkdirSync(archiveRoot, { recursive: true, mode: 0o700 });
+    await runNpm([
+        "pack",
+        "--ignore-scripts",
+        "--pack-destination",
+        archiveRoot,
+        "--",
+        spec,
+    ], onProgress, signal);
+    const archives = readdirSync(archiveRoot)
+        .filter((name) => name.endsWith(".tgz"))
+        .map((name) => join(archiveRoot, name));
+    if (archives.length !== 1 || !statSync(archives[0]).isFile()) {
+        throw new Error("package source did not produce exactly one npm archive");
+    }
+    return archives[0];
+}
+async function cloneGitPackage(spec, destination, onProgress, signal) {
+    const { url, ref } = parseGitSpec(spec);
+    rmSync(destination, { recursive: true, force: true });
+    const args = ["clone", "--no-checkout", "--filter=blob:none", "--", url, destination];
+    await runCommand("git", args, onProgress, signal);
+    await runCommand("git", ["-C", destination, "checkout", "--detach", ref ?? "HEAD"], onProgress, signal);
+}
+export function parseGitSpec(spec) {
+    let value = spec.trim();
+    let shorthand = false;
+    if (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:#.*)?$/.test(value)) {
+        value = `https://github.com/${value}`;
+        shorthand = true;
+    }
+    else if (value.startsWith("github:")) {
+        value = `https://github.com/${value.slice("github:".length)}`;
+        shorthand = true;
+    }
+    else if (value.startsWith("gitlab:")) {
+        value = `https://gitlab.com/${value.slice("gitlab:".length)}`;
+        shorthand = true;
+    }
+    else if (value.startsWith("bitbucket:")) {
+        value = `https://bitbucket.org/${value.slice("bitbucket:".length)}`;
+        shorthand = true;
+    }
+    if (value.startsWith("git+"))
+        value = value.slice(4);
+    const hash = value.lastIndexOf("#");
+    const ref = hash >= 0 ? value.slice(hash + 1).trim() : undefined;
+    const url = hash >= 0 ? value.slice(0, hash) : value;
+    if (!url || url.startsWith("-") || /[\r\n\0]/.test(url)) {
+        throw new Error("git plugin source has an invalid URL");
+    }
+    if (ref && (ref.startsWith("-") || /[\r\n\0]/.test(ref))) {
+        throw new Error("git plugin source has an invalid ref");
+    }
+    const normalizedUrl = shorthand && !url.endsWith(".git") ? `${url}.git` : url;
+    return { url: normalizedUrl, ...(ref ? { ref } : {}) };
+}
+async function materializeWithNpm({ spec, prefix, destination, onProgress, signal, installLinks = false, label, }) {
+    mkdirSync(prefix, { recursive: true, mode: 0o700 });
+    writeFileSync(join(prefix, "package.json"), `${JSON.stringify({ name: "rynx-plugin-materializer", private: true }, null, 2)}\n`, { mode: 0o600 });
+    onProgress(`materializing ${label ?? (installLinks ? "local" : "remote")} plugin ${spec}`);
+    await runNpm([
+        "install",
+        "--prefix",
+        prefix,
+        "--ignore-scripts",
+        "--no-audit",
+        "--no-fund",
+        "--package-lock=false",
+        "--install-strategy=nested",
+        ...(installLinks ? ["--install-links=true"] : []),
+        "--save-exact",
+        "--",
+        spec,
+    ], onProgress, signal);
+    const materializerPackage = readJsonObject(join(prefix, "package.json"), "materializer package.json");
+    const dependencies = materializerPackage.dependencies;
+    if (!isRecord(dependencies)) {
+        throw new Error("npm did not record the materialized plugin package");
+    }
+    const names = Object.keys(dependencies);
+    if (names.length !== 1 || !isSafeNpmPackageName(names[0])) {
+        throw new Error("npm materialization did not resolve exactly one safe package name");
+    }
+    const packageDir = join(prefix, "node_modules", ...names[0].split("/"));
+    const packageReal = requireContainedFile(prefix, packageDir, "materialized package", "directory");
+    copyPackageTree(packageReal, destination, false);
+}
+/** Parse and validate static metadata, validate all executable entry paths, and hash the tree. */
+export function inspectPluginPackage(packageDir, options = {}) {
+    const packageRoot = realpathSync(packageDir);
+    validatePackageSymlinkClosure(packageRoot);
+    const packageJsonPath = requireContainedFile(packageRoot, join(packageRoot, "package.json"), "package.json", "file");
+    const packageJson = readJsonObject(packageJsonPath, "package.json");
+    if (!isRecord(packageJson.rynx) || typeof packageJson.rynx.manifest !== "string") {
+        throw new Error("package.json must declare `rynx.manifest` as a static JSON path");
+    }
+    const manifestPath = resolvePackageEntry(packageRoot, packageJson.rynx.manifest, "rynx.manifest");
+    const manifest = parsePluginManifest(readJsonObject(manifestPath, "plugin manifest"));
+    if (options.requireEntries !== false) {
+        resolvePackageEntry(packageRoot, manifest.runtimeEntry, "runtimeEntry");
+        if (manifest.cliEntry)
+            resolvePackageEntry(packageRoot, manifest.cliEntry, "cliEntry");
+    }
+    const version = typeof packageJson.version === "string" && packageJson.version.trim()
+        ? packageJson.version
+        : undefined;
+    return {
+        manifest,
+        ...(version ? { version } : {}),
+        integrity: hashPackageTree(packageRoot),
+    };
+}
+/**
+ * An installed package must be an immutable closure. Internal npm `.bin`
+ * links are valid, but a link to mutable content outside the promoted package
+ * would make the recorded integrity depend only on the link text.
+ */
+function validatePackageSymlinkClosure(root) {
+    visit(root, "");
+    function visit(candidate, rel) {
+        const stat = lstatSync(candidate);
+        const normalized = rel.split(sep).join("/");
+        if (stat.isSymbolicLink()) {
+            let target;
+            try {
+                target = realpathSync(candidate);
+            }
+            catch {
+                throw new Error(`plugin package contains a broken symlink: ${normalized}`);
+            }
+            if (!isWithin(root, target)) {
+                throw new Error(`plugin package symlink resolves outside the package: ${normalized}`);
+            }
+            return;
+        }
+        if (!stat.isDirectory())
+            return;
+        for (const name of readdirSync(candidate)) {
+            visit(join(candidate, name), join(rel, name));
+        }
+    }
+}
+/** Run package/dependency build scripts only after explicit user approval. */
+export async function rebuildPluginPackage(packageDir, onProgress, signal) {
+    await runNpm([
+        "rebuild",
+        "--prefix",
+        realpathSync(packageDir),
+        "--foreground-scripts",
+        "--no-audit",
+        "--no-fund",
+    ], onProgress, signal);
+}
+function looksLocal(spec) {
+    if (spec.startsWith("file:"))
+        return true;
+    if (spec === "~" || spec.startsWith("~/"))
+        return true;
+    if (spec.startsWith("./") || spec.startsWith("../") || isAbsolute(spec))
+        return true;
+    try {
+        return existsSync(spec) && statSync(spec).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function toLocalDir(spec) {
+    let path;
+    if (spec.startsWith("file:")) {
+        try {
+            path = fileURLToPath(spec);
+        }
+        catch {
+            path = spec.slice("file:".length);
+        }
+    }
+    else {
+        path = spec;
+    }
+    if (path === "~" || path.startsWith("~/"))
+        path = join(homedir(), path.slice(1));
+    return resolve(path);
+}
+function copyPackageTree(source, destination, excludeNodeModules) {
+    cpSync(source, destination, {
+        recursive: true,
+        errorOnExist: true,
+        force: false,
+        dereference: false,
+        filter: (entry) => {
+            const rel = relative(source, entry);
+            if (!rel)
+                return true;
+            const segments = rel.split(sep);
+            if (segments.includes(".git"))
+                return false;
+            // npm generates command shims as absolute symlinks into its disposable
+            // materialization prefix. Plugin entries resolve tools by package path,
+            // so these non-runtime shims must not escape into the immutable closure.
+            if (segments.includes(".bin"))
+                return false;
+            return !excludeNodeModules || !segments.includes("node_modules");
+        },
+    });
+}
+function findPnpmWorkspaceRoot(start) {
+    let current = start;
+    while (true) {
+        if (existsSync(join(current, "pnpm-workspace.yaml")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+async function stageLocalWorkspaceClosure(pluginRoot, workspaceRoot, stagingRoot) {
+    const packages = new Map();
+    const workspaceNodeModules = existsSync(join(workspaceRoot, "node_modules"))
+        ? realpathSync(join(workspaceRoot, "node_modules"))
+        : undefined;
+    const visit = (source) => {
+        const sourceReal = realpathSync(source);
+        const packageJson = readJsonObject(join(sourceReal, "package.json"), "package.json");
+        const name = packageJson.name;
+        if (typeof name !== "string" || !isSafeNpmPackageName(name)) {
+            throw new Error(`local workspace package has an invalid name: ${String(name)}`);
+        }
+        const existing = packages.get(name);
+        if (existing) {
+            if (existing.source !== sourceReal) {
+                throw new Error(`local workspace contains duplicate package name: ${name}`);
+            }
+            return;
+        }
+        const key = createHash("sha256").update(name).digest("hex").slice(0, 16);
+        packages.set(name, {
+            source: sourceReal,
+            staged: join(stagingRoot, "packages", key),
+            archive: join(stagingRoot, "archives", `${key}.tgz`),
+        });
+        for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+            const dependencies = packageJson[field];
+            if (!isRecord(dependencies))
+                continue;
+            for (const [dependencyName, spec] of Object.entries(dependencies)) {
+                const dependencyPath = join(sourceReal, "node_modules", ...dependencyName.split("/"));
+                if (!existsSync(dependencyPath)) {
+                    if (typeof spec === "string" && spec.startsWith("workspace:")) {
+                        throw new Error(`local workspace dependency is not installed: ${name} -> ${dependencyName}`);
+                    }
+                    continue;
+                }
+                const dependencyReal = realpathSync(dependencyPath);
+                if (!isWithin(workspaceRoot, dependencyReal) ||
+                    (workspaceNodeModules && isWithin(workspaceNodeModules, dependencyReal))) {
+                    continue;
+                }
+                const dependencyPackage = readJsonObject(join(dependencyReal, "package.json"), `${dependencyName} package.json`);
+                if (dependencyPackage.name !== dependencyName) {
+                    throw new Error(`local workspace dependency identity mismatch: ${dependencyName}`);
+                }
+                visit(dependencyReal);
+            }
+        }
+    };
+    rmSync(stagingRoot, { recursive: true, force: true });
+    mkdirSync(stagingRoot, { recursive: true, mode: 0o700 });
+    visit(pluginRoot);
+    for (const entry of packages.values())
+        copyPackageTree(entry.source, entry.staged, true);
+    for (const entry of packages.values()) {
+        const file = join(entry.staged, "package.json");
+        const packageJson = readJsonObject(file, "staged package.json");
+        for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+            const dependencies = packageJson[field];
+            if (!isRecord(dependencies))
+                continue;
+            for (const dependencyName of Object.keys(dependencies)) {
+                const target = packages.get(dependencyName);
+                if (target)
+                    dependencies[dependencyName] = `file:${target.archive}`;
+            }
+        }
+        writeFileSync(file, `${JSON.stringify(packageJson, null, 2)}\n`, { mode: 0o600 });
+    }
+    await Promise.all([...packages.values()].map((entry) => createPackageArchive(entry.staged, entry.archive)));
+    const pluginName = readJsonObject(join(pluginRoot, "package.json"), "package.json").name;
+    const plugin = typeof pluginName === "string" ? packages.get(pluginName) : undefined;
+    if (!plugin)
+        throw new Error("local workspace plugin was not staged");
+    return { pluginArchive: plugin.archive, packageCount: packages.size };
+}
+async function createPackageArchive(packageRoot, archive) {
+    mkdirSync(dirname(archive), { recursive: true, mode: 0o700 });
+    await createTar({
+        cwd: packageRoot,
+        file: archive,
+        gzip: true,
+        portable: true,
+        prefix: "package",
+        noMtime: true,
+    }, readdirSync(packageRoot));
+}
+function hasProductionDependencies(packageRoot) {
+    const packageJson = readJsonObject(join(packageRoot, "package.json"), "package.json");
+    return ["dependencies", "optionalDependencies", "peerDependencies"].some((key) => {
+        const value = packageJson[key];
+        return isRecord(value) && Object.keys(value).length > 0;
+    });
+}
+function resolvePackageEntry(packageRoot, entry, label) {
+    if (!entry.startsWith("./") || entry.includes("\\") || entry.includes("\0")) {
+        throw new Error(`${label} must be a package-root-relative POSIX path starting with ./`);
+    }
+    const segments = entry.slice(2).split("/");
+    if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
+        throw new Error(`${label} must not contain empty, . or .. segments`);
+    }
+    return requireContainedFile(packageRoot, resolve(packageRoot, entry), label, "file");
+}
+function requireContainedFile(root, candidate, label, kind) {
+    let rootReal;
+    let candidateReal;
+    try {
+        rootReal = realpathSync(root);
+        candidateReal = realpathSync(candidate);
+    }
+    catch {
+        throw new Error(`${label} does not exist`);
+    }
+    if (!isWithin(rootReal, candidateReal)) {
+        throw new Error(`${label} resolves outside the plugin package`);
+    }
+    const stat = statSync(candidateReal);
+    if (kind === "file" ? !stat.isFile() : !stat.isDirectory()) {
+        throw new Error(`${label} must be a ${kind}`);
+    }
+    return candidateReal;
+}
+function isWithin(root, candidate) {
+    const rel = relative(root, candidate);
+    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}
+function readJsonObject(path, label) {
+    let raw;
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile())
+            throw new Error("not a file");
+        if (stat.size > MAX_METADATA_BYTES)
+            throw new Error("metadata is too large");
+        raw = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        throw new Error(`cannot read ${label}: ${messageOf(error)}`);
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed))
+            throw new Error("must contain a JSON object");
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`invalid ${label}: ${messageOf(error)}`);
+    }
+}
+function hashPackageTree(root) {
+    const hash = createHash("sha256");
+    hash.update("rynx-plugin-package-v1\0");
+    visit(root, "");
+    return `sha256-${hash.digest("base64")}`;
+    function visit(path, rel) {
+        const stat = lstatSync(path);
+        const normalized = rel.split(sep).join("/");
+        if (stat.isDirectory()) {
+            hash.update(`d\0${normalized}\0`);
+            for (const name of readdirSync(path).sort())
+                visit(join(path, name), join(rel, name));
+            return;
+        }
+        if (stat.isFile()) {
+            hash.update(`f\0${normalized}\0${stat.size}\0`);
+            hash.update(readFileSync(path));
+            return;
+        }
+        if (stat.isSymbolicLink()) {
+            hash.update(`l\0${normalized}\0${readlinkSync(path)}\0`);
+            return;
+        }
+        throw new Error(`unsupported package entry: ${normalized}`);
+    }
+}
+function isSafeNpmPackageName(name) {
+    return /^(?:@[A-Za-z0-9][A-Za-z0-9._-]*\/)?[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name);
+}
+function runNpm(args, onProgress, signal) {
+    return runCommand("npm", args, onProgress, signal);
+}
+function runCommand(command, args, onProgress, signal, cwd) {
+    return new Promise((resolveDone, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("plugin installation aborted"));
+            return;
+        }
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let settled = false;
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener("abort", abort);
+            callback();
+        };
+        const abort = () => child.kill();
+        signal?.addEventListener("abort", abort, { once: true });
+        const onData = (buffer) => {
+            for (const line of buffer.toString().split(/\r?\n/)) {
+                if (line.trim())
+                    onProgress(line);
+            }
+        };
+        child.stdout?.on("data", onData);
+        child.stderr?.on("data", onData);
+        child.on("error", (error) => settle(() => reject(error)));
+        child.on("close", (code) => settle(() => {
+            if (signal?.aborted)
+                reject(new Error("plugin installation aborted"));
+            else if (code === 0)
+                resolveDone();
+            else
+                reject(new Error(`${command} exited with code ${code ?? "null"}`));
+        }));
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/plugin-runtime-control.d.ts

@@ -0,0 +1,2 @@
+export declare function reloadResidentPluginRuntime(pluginId: string): Promise<unknown>;
+export declare function ensureResidentPluginRuntime(pluginId: string): Promise<unknown>;

package/dist/plugin-runtime-control.js

@@ -0,0 +1,37 @@
+import { ensureDaemonControlEndpoint } from "./control-endpoint.js";
+const RELOAD_TIMEOUT_MS = 30_000;
+export async function reloadResidentPluginRuntime(pluginId) {
+    return requestResidentPluginRuntime(pluginId, "reload");
+}
+export async function ensureResidentPluginRuntime(pluginId) {
+    return requestResidentPluginRuntime(pluginId, "ensure");
+}
+async function requestResidentPluginRuntime(pluginId, operation) {
+    if (!/^[a-z][a-z0-9-]{0,62}$/.test(pluginId))
+        throw new Error("invalid plugin id");
+    const endpoint = await ensureDaemonControlEndpoint();
+    const response = await fetch(`${endpoint.origin}/api/internal/plugin-runtimes/${encodeURIComponent(pluginId)}/${operation}`, {
+        method: "POST",
+        headers: { "x-rynx-management-token": endpoint.managementToken },
+        signal: AbortSignal.timeout(RELOAD_TIMEOUT_MS),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new Error(readError(body) || `plugin runtime refresh failed (${response.status})`);
+    }
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        throw new Error("daemon returned an invalid plugin runtime refresh response");
+    }
+}
+function readError(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return typeof parsed.error === "string" ? parsed.error : undefined;
+    }
+    catch {
+        return body.trim().slice(0, 2_000) || undefined;
+    }
+}

package/dist/plugin-store.d.ts

@@ -1,27 +1,56 @@
-export type PluginSource = "npm" | "local";
+/**
+ * Durable inventory of installed plugin packages.
+ *
+ * The registry stores only static, validated manifest data and a host-owned
+ * installation path. Runtime modules are never imported while reading this
+ * table. Rows from the pre-v1 executable-manifest format remain visible to the
+ * CLI, but are not runnable and must be reinstalled.
+ */
+import { type PluginCapability, type PluginManifestV1 } from "@rynx-ai/plugin-sdk";
+export type PluginSource = "npm" | "local" | "git" | "url";
 export interface PluginRecord {
-    /** Canonical plugin name (short id, e.g. `lark`); primary key. */
+    /** Manifest id. The SQLite column remains `name` for migration stability. */
     name: string;
-    /** Install spec: an npm package spec, or an absolute local directory. */
+    /** User-supplied install source, retained for an explicit update. */
     spec: string;
     source: PluginSource;
     version?: string;
+    /** Whether daemon runtime contributions are loaded; explicit CLI stays available. */
     enabled: boolean;
     installedAt: string;
+    updatedAt: string;
+    /** Host-generated immutable installation root. Missing only on legacy rows. */
+    installPath?: string;
+    /** Validated, pure-data manifest. Missing only on legacy rows. */
+    manifest?: PluginManifestV1;
+    /** sha256 integrity string for the materialized package. */
+    integrity?: string;
+    /** Capabilities approved for this installation. */
+    grants: PluginCapability[];
 }
-/** All installed plugins, enabled or not. */
+export interface RunnablePluginRecord extends PluginRecord {
+    installPath: string;
+    manifest: PluginManifestV1;
+    integrity: string;
+}
+/** All installed plugins, including incompatible legacy rows. */
 export declare function listPlugins(): PluginRecord[];
-/** Only enabled plugins — the set the loader imports. */
-export declare function listEnabledPlugins(): PluginRecord[];
+/** Enabled v1 installations that are safe for the runner to consider. */
+export declare function listEnabledPlugins(): RunnablePluginRecord[];
 export declare function getPlugin(name: string): PluginRecord | undefined;
-/** Insert or replace a plugin record (idempotent install). */
+/** Atomically point a plugin id at a completely materialized installation. */
 export declare function upsertPlugin(rec: {
     name: string;
     spec: string;
     source: PluginSource;
     version?: string;
+    installPath: string;
+    manifest: PluginManifestV1;
+    integrity: string;
+    grants: readonly PluginCapability[];
     enabled?: boolean;
 }): void;
 export declare function setPluginEnabled(name: string, enabled: boolean): void;
-/** Remove a plugin record. Returns false if it wasn't present. */
+/** Remove only the registry row. Package deletion is owned by the installer. */
 export declare function removePlugin(name: string): boolean;
+export declare function isRunnablePluginRecord(record: PluginRecord): record is RunnablePluginRecord;