@rynx-ai/daemon 0.1.10 → 0.1.11-beta.2

package/dist/plugin-management-service.d.ts

@@ -1,49 +1,55 @@
-import { type PluginInstallCommitInput, type PluginInstallCommitResult, type PluginInstallPreparation, type PluginInstallPrepareInput } from "@rynx-ai/protocol/plugin-management";
-import { type PluginCapability } from "@rynx-ai/plugin-sdk";
+import type { PluginInstallCommitInput, PluginInstallCommitResult, PluginInstallPreparation, PluginInstallPrepareInput, PluginManagementItem } from "@rynx-ai/protocol/plugin-management";
+import type { PluginJsonValue } from "@rynx-ai/plugin-sdk";
 import { type PreparePluginInstallationOptions, type PreparedPluginInstallation } from "./plugin-installer.js";
-import { type PluginRecord, type PluginSource } from "./plugin-store.js";
-export type PluginManagementState = "enabled" | "disabled" | "reinstall-required";
-/** Redacted management view; installation paths and source specs never cross RPC. */
-export interface PluginManagementItem {
-    id: string;
-    version?: string;
-    source: PluginSource;
-    state: PluginManagementState;
-    enabled: boolean;
-    requestedCapabilities: PluginCapability[];
-    grants: PluginCapability[];
-    updatedAt: string;
-}
+import { type PluginMarketplaceRecord } from "./plugin-marketplace.js";
+import { type PluginRecord } from "./plugin-store.js";
+import type { PluginSupervisor } from "./plugin-supervisor.js";
 export interface PluginManagementServiceDependencies {
     list(): PluginRecord[];
     get(id: string): PluginRecord | undefined;
     setEnabled(id: string, enabled: boolean): void;
     uninstall(id: string): Promise<boolean>;
     prepare(spec: string, onProgress: (line: string) => void, options: PreparePluginInstallationOptions): Promise<PreparedPluginInstallation>;
+    resolveMarketplace(identity: string): {
+        marketplace: {
+            marketplaceId: string;
+        };
+        pluginId: string;
+        spec: string;
+    };
+    getMarketplace(id: string): Pick<PluginMarketplaceRecord, "marketplaceId" | "sourceType" | "resolvedRevision" | "builtIn"> | undefined;
 }
 export interface PluginManagementServiceOptions {
     preparationTtlMs?: number;
     now?: () => number;
     token?: () => string;
-    schedule?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    supervisor?: PluginSupervisor;
 }
-/**
- * Daemon-owned plugin registry mutations exposed to the authenticated local
- * management API. Package installation remains outside this service until its
- * capability approval is cryptographically bound to one staged artifact.
- */
 export declare class PluginManagementService {
     private readonly dependencies;
     private readonly pending;
     private readonly now;
     private readonly token;
-    private readonly schedule;
     private readonly preparationTtlMs;
+    private readonly supervisor?;
+    private readonly activeSettingsCalls;
     constructor(dependencies?: PluginManagementServiceDependencies, options?: PluginManagementServiceOptions);
     list(): {
         plugins: PluginManagementItem[];
     };
-    setEnabled(id: string, enabled: boolean): PluginManagementItem | undefined;
+    settingsUi(id: string): {
+        generation: string;
+        assetGeneration: string;
+        html: string;
+    } | undefined;
+    settingsUiAsset(id: string, assetGeneration: string, assetPath: string): {
+        contentType: string;
+        data: Buffer;
+    } | undefined;
+    callSettings(id: string, generation: string, method: string, params: PluginJsonValue | undefined, options?: {
+        signal?: AbortSignal;
+    }): Promise<PluginJsonValue>;
+    setEnabled(id: string, enabled: boolean): Promise<PluginManagementItem | undefined>;
     uninstall(id: string): Promise<boolean>;
     prepareInstallation(input: PluginInstallPrepareInput, options?: {
         signal?: AbortSignal;
@@ -55,4 +61,5 @@ export declare class PluginManagementService {
     dispose(): void;
     private takePreparation;
     private uniqueToken;
+    private managementItem;
 }

package/dist/plugin-management-service.js

@@ -1,27 +1,30 @@
-import { randomBytes } from "node:crypto";
-import { PLUGIN_ID_PATTERN } from "@rynx-ai/plugin-sdk";
+import { createHash, randomBytes } from "node:crypto";
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, extname, relative, resolve, sep } from "node:path";
 import { preparePluginInstallation, uninstallPlugin, } from "./plugin-installer.js";
-import { getPlugin, isRunnablePluginRecord, listPlugins, setPluginEnabled, } from "./plugin-store.js";
+import { getPluginMarketplace, resolveMarketplacePlugin, } from "./plugin-marketplace.js";
+import { resolvePackagePath } from "./plugin-package.js";
+import { getPlugin, listPlugins, setPluginEnabled, } from "./plugin-store.js";
 const defaultDependencies = {
     list: listPlugins,
     get: getPlugin,
     setEnabled: setPluginEnabled,
     uninstall: (id) => uninstallPlugin(id),
     prepare: preparePluginInstallation,
+    resolveMarketplace: resolveMarketplacePlugin,
+    getMarketplace: getPluginMarketplace,
 };
 const DEFAULT_PREPARATION_TTL_MS = 5 * 60 * 1_000;
-/**
- * Daemon-owned plugin registry mutations exposed to the authenticated local
- * management API. Package installation remains outside this service until its
- * capability approval is cryptographically bound to one staged artifact.
- */
+const MAX_SETTINGS_UI_DOCUMENT_BYTES = 2 * 1024 * 1024;
+const MAX_SETTINGS_UI_ASSET_BYTES = 16 * 1024 * 1024;
 export class PluginManagementService {
     dependencies;
     pending = new Map();
     now;
     token;
-    schedule;
     preparationTtlMs;
+    supervisor;
+    activeSettingsCalls = new Map();
     constructor(dependencies = defaultDependencies, options = {}) {
         this.dependencies = dependencies;
         this.preparationTtlMs = options.preparationTtlMs ?? DEFAULT_PREPARATION_TTL_MS;
@@ -30,62 +33,169 @@ export class PluginManagementService {
         }
         this.now = options.now ?? Date.now;
         this.token = options.token ?? (() => randomBytes(32).toString("base64url"));
-        this.schedule = options.schedule ?? setTimeout;
+        this.supervisor = options.supervisor;
     }
     list() {
-        return { plugins: this.dependencies.list().map(toManagementItem) };
+        return { plugins: this.dependencies.list().map((record) => this.managementItem(record)) };
     }
-    setEnabled(id, enabled) {
-        validatePluginId(id);
+    settingsUi(id) {
+        const record = this.dependencies.get(id);
+        const entry = record?.manifest.settings?.ui.entry;
+        if (!record || !entry)
+            return undefined;
+        const path = resolvePackagePath(record.installPath, entry, "settings.ui.entry", "file");
+        const info = lstatSync(path);
+        if (info.size > MAX_SETTINGS_UI_DOCUMENT_BYTES) {
+            throw new Error("plugin settings UI exceeds 2 MiB");
+        }
+        return {
+            generation: record.integrity,
+            assetGeneration: settingsUiAssetGeneration(record.integrity),
+            html: readFileSync(path, "utf8"),
+        };
+    }
+    settingsUiAsset(id, assetGeneration, assetPath) {
+        const record = this.dependencies.get(id);
+        const entry = record?.manifest.settings?.ui.entry;
+        if (!record || !entry)
+            return undefined;
+        if (assetGeneration !== settingsUiAssetGeneration(record.integrity))
+            return undefined;
+        if (!isSettingsUiAssetPath(assetPath))
+            return undefined;
+        const entryPath = resolvePackagePath(record.installPath, entry, "settings.ui.entry", "file");
+        const root = realpathSync(dirname(entryPath));
+        const unresolved = resolve(root, ...assetPath.split("/"));
+        let candidate;
+        let info;
+        try {
+            info = lstatSync(unresolved);
+            if (!info.isFile() || info.isSymbolicLink())
+                return undefined;
+            candidate = realpathSync(unresolved);
+        }
+        catch {
+            return undefined;
+        }
+        const rel = relative(root, candidate);
+        if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || resolve(root, rel) !== candidate) {
+            return undefined;
+        }
+        if (info.size > MAX_SETTINGS_UI_ASSET_BYTES) {
+            throw new Error("plugin settings UI asset exceeds 16 MiB");
+        }
+        const contentType = settingsUiAssetContentType(candidate);
+        if (!contentType)
+            return undefined;
+        return { contentType, data: readFileSync(candidate) };
+    }
+    async callSettings(id, generation, method, params, options = {}) {
+        const record = this.dependencies.get(id);
+        if (!record)
+            throw new Error(`plugin "${id}" not found`);
+        if (record.integrity !== generation)
+            throw new Error("plugin settings UI generation is stale");
+        if (!this.supervisor)
+            throw new Error("plugin settings background is unavailable");
+        const active = this.activeSettingsCalls.get(record.canonicalId) ?? 0;
+        if (active >= 16)
+            throw new Error("plugin settings UI has too many requests in flight");
+        this.activeSettingsCalls.set(record.canonicalId, active + 1);
+        const deadline = AbortSignal.timeout(30_000);
+        const combined = options.signal
+            ? AbortSignal.any([options.signal, deadline])
+            : deadline;
+        try {
+            return await this.supervisor.settingsCall(record.canonicalId, generation, method, params, { signal: combined });
+        }
+        finally {
+            const remaining = (this.activeSettingsCalls.get(record.canonicalId) ?? 1) - 1;
+            if (remaining <= 0)
+                this.activeSettingsCalls.delete(record.canonicalId);
+            else
+                this.activeSettingsCalls.set(record.canonicalId, remaining);
+        }
+    }
+    async setEnabled(id, enabled) {
         const current = this.dependencies.get(id);
         if (!current)
             return undefined;
-        if (!isRunnablePluginRecord(current)) {
-            throw new Error(`plugin "${id}" must be reinstalled before it can be ${enabled ? "enabled" : "disabled"}`);
+        const mutate = () => {
+            this.dependencies.setEnabled(current.canonicalId, enabled);
+            const updated = this.dependencies.get(current.canonicalId);
+            if (!updated)
+                throw new Error(`plugin "${current.canonicalId}" disappeared`);
+            return updated;
+        };
+        if (this.supervisor) {
+            await this.supervisor.changeEnabled(current, enabled, mutate);
         }
-        this.dependencies.setEnabled(id, enabled);
-        const updated = this.dependencies.get(id);
-        if (!updated) {
-            throw new Error(`plugin "${id}" disappeared while updating its state`);
+        else {
+            mutate();
         }
-        return toManagementItem(updated);
+        return this.managementItem(this.dependencies.get(current.canonicalId));
     }
     async uninstall(id) {
-        validatePluginId(id);
-        return this.dependencies.uninstall(id);
+        const current = this.dependencies.get(id);
+        if (!current)
+            return false;
+        if (this.dependencies.getMarketplace(current.marketplaceId)?.builtIn) {
+            throw new Error(`bundled plugin "${current.canonicalId}" cannot be uninstalled; disable it instead`);
+        }
+        if (this.supervisor) {
+            return await this.supervisor.uninstallInstallation(current.canonicalId, () => this.dependencies.uninstall(current.canonicalId));
+        }
+        return await this.dependencies.uninstall(current.canonicalId);
     }
     async prepareInstallation(input, options = {}) {
         options.signal?.throwIfAborted();
         let spec;
-        let expectedId;
-        if (input.operation === "install") {
-            if (!input.spec)
-                throw new Error("plugin install source is required");
+        let prepareOptions;
+        if (input.operation === "install" && input.marketplacePlugin) {
+            const resolved = this.dependencies.resolveMarketplace(input.marketplacePlugin);
+            spec = resolved.spec;
+            prepareOptions = {
+                marketplaceId: resolved.marketplace.marketplaceId,
+                expectedId: resolved.pluginId,
+                ...(options.signal ? { signal: options.signal } : {}),
+            };
+        }
+        else if (input.operation === "install" && input.spec) {
             spec = input.spec;
+            prepareOptions = options.signal ? { signal: options.signal } : {};
         }
-        else {
-            if (!input.pluginId)
-                throw new Error("plugin update id is required");
-            validatePluginId(input.pluginId);
+        else if (input.operation === "update" && input.pluginId) {
             const existing = this.dependencies.get(input.pluginId);
             if (!existing)
                 throw new Error(`plugin "${input.pluginId}" not found`);
-            if (!isRunnablePluginRecord(existing)) {
-                throw new Error(`plugin "${input.pluginId}" uses the removed legacy format; reinstall it`);
+            const marketplace = this.dependencies.getMarketplace(existing.marketplaceId);
+            if (marketplace) {
+                const resolved = this.dependencies.resolveMarketplace(existing.canonicalId);
+                if (resolved.marketplace.marketplaceId !== existing.marketplaceId ||
+                    resolved.pluginId !== existing.pluginId) {
+                    throw new Error(`marketplace resolution changed identity for "${existing.canonicalId}"`);
+                }
+                spec = resolved.spec;
             }
-            spec = existing.spec;
-            expectedId = existing.name;
-        }
-        const prepared = await this.dependencies.prepare(spec, () => { }, {
-            allowScripts: input.allowScripts,
-            ...(expectedId ? { expectedId } : {}),
-            ...(options.signal ? { signal: options.signal } : {}),
-        });
+            else {
+                spec = existing.spec;
+            }
+            prepareOptions = {
+                expectedId: existing.pluginId,
+                expectedIdentity: existing.canonicalId,
+                marketplaceId: existing.marketplaceId,
+                ...(options.signal ? { signal: options.signal } : {}),
+            };
+        }
+        else {
+            throw new Error("invalid plugin installation request");
+        }
+        const prepared = await this.dependencies.prepare(spec, () => { }, prepareOptions);
         try {
             options.signal?.throwIfAborted();
             const token = this.uniqueToken();
             const expiresAtMs = this.now() + this.preparationTtlMs;
-            const expiryTimer = this.schedule(() => {
+            const expiryTimer = setTimeout(() => {
                 const current = this.pending.get(token);
                 if (!current || current.prepared !== prepared)
                     return;
@@ -117,23 +227,22 @@ export class PluginManagementService {
                 throw new Error("prepared plugin digest does not match expected digest");
             }
             if (prepared.existing && !input.overwrite) {
-                throw new Error(`plugin "${prepared.name}" already exists; explicit overwrite approval is required`);
+                throw new Error(`plugin "${prepared.canonicalId}" already exists; explicit overwrite confirmation is required`);
             }
-            const grants = input.grants.map((grant) => {
-                const capability = prepared.manifest.requestedCapabilities.find((requested) => requested === grant);
-                if (!capability)
-                    throw new Error(`plugin capability was not requested: ${grant}`);
-                return capability;
-            });
-            await prepared.commit({
-                grants,
-                expectedDigest: input.expectedDigest,
-                signal: options.signal,
-            });
-            const installed = this.dependencies.get(prepared.name);
-            if (!installed)
-                throw new Error(`plugin "${prepared.name}" was not registered after commit`);
-            return { plugin: toManagementItem(installed) };
+            const commit = async () => {
+                await prepared.commit({
+                    expectedDigest: input.expectedDigest,
+                    signal: options.signal,
+                });
+                const installed = this.dependencies.get(prepared.canonicalId);
+                if (!installed)
+                    throw new Error(`plugin "${prepared.canonicalId}" was not registered`);
+                return installed;
+            };
+            const installed = this.supervisor
+                ? await this.supervisor.cutoverInstallation(prepared.canonicalId, commit).then(() => this.dependencies.get(prepared.canonicalId))
+                : await commit();
+            return { plugin: this.managementItem(installed) };
         }
         finally {
             prepared.discard();
@@ -170,71 +279,147 @@ export class PluginManagementService {
         }
         throw new Error("failed to allocate a plugin preparation token");
     }
+    managementItem(record) {
+        return toManagementItem(record, Boolean(record.manifest.settings), pluginUpdateState(record, this.dependencies.getMarketplace(record.marketplaceId)));
+    }
 }
-function toManagementItem(record) {
-    const runnable = isRunnablePluginRecord(record);
+function toManagementItem(record, settingsAvailable = false, updateState = "unknown") {
     return {
-        id: record.name,
-        ...(record.version ? { version: record.version } : {}),
+        id: record.canonicalId,
+        pluginId: record.pluginId,
+        marketplaceId: record.marketplaceId,
+        version: record.version,
         source: record.source,
-        state: !runnable
-            ? "reinstall-required"
-            : record.enabled
-                ? "enabled"
-                : "disabled",
-        enabled: runnable && record.enabled,
-        requestedCapabilities: runnable ? [...record.manifest.requestedCapabilities] : [],
-        grants: [...record.grants],
+        state: record.enabled ? "enabled" : "disabled",
+        updateState,
+        enabled: record.enabled,
+        runtimeState: record.manifest.runtime ? record.runtimeState : "absent",
+        ...(record.runtimeError ? { runtimeError: record.runtimeError } : {}),
+        capabilities: [...record.manifest.capabilities],
+        hasSettingsUi: settingsAvailable,
         updatedAt: record.updatedAt,
     };
 }
 function toInstallPreparation(token, expiresAtMs, prepared) {
-    const requested = [...prepared.manifest.requestedCapabilities];
-    const prior = prepared.existing?.grants ?? [];
-    const requestedSet = new Set(requested);
-    const priorSet = new Set(prior);
     return {
         token,
         expiresAt: new Date(expiresAtMs).toISOString(),
         artifact: {
-            id: prepared.name,
-            ...(prepared.version ? { version: prepared.version } : {}),
+            id: prepared.canonicalId,
+            pluginId: prepared.pluginId,
+            marketplaceId: prepared.marketplaceId,
+            version: prepared.version,
             source: prepared.source,
-            digest: prepared.integrity,
-            requestedCapabilities: requested,
-            requiresBuildScripts: Boolean(prepared.manifest.requiresBuildScripts),
-        },
-        ...(prepared.existing
-            ? {
-                existing: {
-                    id: prepared.existing.name,
-                    ...(prepared.existing.version
-                        ? { version: prepared.existing.version }
-                        : {}),
-                    source: prepared.existing.source,
-                    state: managementState(prepared.existing),
-                    grants: [...prepared.existing.grants],
+            resolvedSource: prepared.requestedSource.type === "git"
+                ? {
+                    type: "git",
+                    repository: prepared.requestedSource.url,
+                    subdirectory: prepared.requestedSource.subdir ?? ".",
+                    commit: prepared.resolvedRevision,
+                }
+                : {
+                    type: "local",
+                    subdirectory: prepared.requestedSource.subdir ?? ".",
                 },
-            }
-            : {}),
-        capabilityDiff: {
-            added: requested.filter((capability) => !priorSet.has(capability)),
-            retained: requested.filter((capability) => priorSet.has(capability)),
-            removed: prior.filter((capability) => !requestedSet.has(capability)),
+            digest: prepared.integrity,
+            capabilities: [...prepared.manifest.capabilities],
+            hasRuntime: Boolean(prepared.manifest.runtime),
+            hasSettingsUi: Boolean(prepared.manifest.settings),
+            ...(prepared.manifest.runtime ? {
+                runtimeEntry: "entry" in prepared.manifest.runtime
+                    ? {
+                        type: "module",
+                        entry: prepared.manifest.runtime.entry,
+                    }
+                    : {
+                        type: "process",
+                        command: prepared.manifest.runtime.command,
+                        args: [...(prepared.manifest.runtime.args ?? [])],
+                    },
+            } : {}),
+            ...(prepared.manifest.settings?.background ? {
+                settingsBackgroundEntry: "entry" in prepared.manifest.settings.background
+                    ? {
+                        type: "module",
+                        entry: prepared.manifest.settings.background.entry,
+                    }
+                    : {
+                        type: "process",
+                        command: prepared.manifest.settings.background.command,
+                        args: [...(prepared.manifest.settings.background.args ?? [])],
+                    },
+            } : {}),
+            ...(prepared.manifest.commands ? {
+                commandsEntry: prepared.manifest.commands.command,
+            } : {}),
+            ...(prepared.manifest.settings ? {
+                settingsUiEntry: prepared.manifest.settings.ui.entry,
+            } : {}),
+            ...(prepared.manifest.skills ? { skillDirectory: prepared.manifest.skills } : {}),
         },
+        ...(prepared.existing ? {
+            existing: {
+                id: prepared.existing.canonicalId,
+                version: prepared.existing.version,
+                source: prepared.existing.source,
+                state: prepared.existing.enabled ? "enabled" : "disabled",
+            },
+            unchanged: prepared.existing.integrity === prepared.integrity,
+        } : {}),
     };
 }
-function managementState(record) {
-    return !isRunnablePluginRecord(record)
-        ? "reinstall-required"
-        : record.enabled
-            ? "enabled"
-            : "disabled";
+function pluginUpdateState(record, marketplace) {
+    if (!marketplace || marketplace.sourceType !== "git" || record.source !== "git") {
+        return "unknown";
+    }
+    return record.resolvedRevision === marketplace.resolvedRevision
+        ? "current"
+        : "available";
 }
 function invalidPreparationError() {
-    return new Error("plugin installation preparation is invalid or expired");
+    return new Error("plugin installation preparation is invalid, expired, or already consumed");
 }
-function validatePluginId(id) {
-    if (!PLUGIN_ID_PATTERN.test(id))
-        throw new Error("invalid plugin id");
+function settingsUiAssetGeneration(integrity) {
+    return createHash("sha256").update(integrity).digest("base64url");
+}
+function isSettingsUiAssetPath(value) {
+    if (!value ||
+        value.length > 1024 ||
+        value.includes("\\") ||
+        value.includes("\0") ||
+        value.startsWith("/")) {
+        return false;
+    }
+    return value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function settingsUiAssetContentType(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".js":
+        case ".mjs":
+            return "text/javascript; charset=utf-8";
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".json":
+        case ".map":
+            return "application/json; charset=utf-8";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        case ".gif":
+            return "image/gif";
+        case ".ico":
+            return "image/x-icon";
+        case ".woff":
+            return "font/woff";
+        case ".woff2":
+            return "font/woff2";
+        case ".ttf":
+            return "font/ttf";
+        default:
+            return undefined;
+    }
 }

package/dist/plugin-marketplace.d.ts

@@ -0,0 +1,35 @@
+import { type PluginMarketplaceV1, type PluginPackageSourceV1 } from "@rynx-ai/plugin-sdk";
+import { type PluginPackageMaterializer } from "./plugin-package.js";
+export interface PluginMarketplaceRecord {
+    marketplaceId: string;
+    sourceType: "git" | "local";
+    builtIn: boolean;
+    requestedSource: PluginPackageSourceV1;
+    resolvedRevision: string;
+    sourceFingerprint: string;
+    catalog: PluginMarketplaceV1;
+    createdAt: string;
+    refreshedAt: string;
+}
+export declare function listPluginMarketplaces(): PluginMarketplaceRecord[];
+export declare function getPluginMarketplace(id: string): PluginMarketplaceRecord | undefined;
+export declare function addPluginMarketplace(spec: string, options?: {
+    alias?: string;
+    allowSourceRebind?: boolean;
+    builtIn?: boolean;
+    signal?: AbortSignal;
+    materializer?: PluginPackageMaterializer;
+    onProgress?: (line: string) => void;
+}): Promise<PluginMarketplaceRecord>;
+export declare function refreshPluginMarketplace(marketplaceId: string, options?: {
+    signal?: AbortSignal;
+    materializer?: PluginPackageMaterializer;
+    onProgress?: (line: string) => void;
+}): Promise<PluginMarketplaceRecord>;
+export declare function removePluginMarketplace(marketplaceId: string): boolean;
+export declare function isBuiltInPluginMarketplace(marketplaceId: string): boolean;
+export declare function resolveMarketplacePlugin(identity: string): {
+    marketplace: PluginMarketplaceRecord;
+    pluginId: string;
+    spec: string;
+};