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

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

@@ -0,0 +1,58 @@
+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 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;
+}
+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>;
+}
+export interface PluginManagementServiceOptions {
+    preparationTtlMs?: number;
+    now?: () => number;
+    token?: () => string;
+    schedule?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+}
+/**
+ * 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;
+    constructor(dependencies?: PluginManagementServiceDependencies, options?: PluginManagementServiceOptions);
+    list(): {
+        plugins: PluginManagementItem[];
+    };
+    setEnabled(id: string, enabled: boolean): PluginManagementItem | undefined;
+    uninstall(id: string): Promise<boolean>;
+    prepareInstallation(input: PluginInstallPrepareInput, options?: {
+        signal?: AbortSignal;
+    }): Promise<PluginInstallPreparation>;
+    commitInstallation(token: string, input: PluginInstallCommitInput, options?: {
+        signal?: AbortSignal;
+    }): Promise<PluginInstallCommitResult>;
+    cancelPreparation(token: string): boolean;
+    dispose(): void;
+    private takePreparation;
+    private uniqueToken;
+}

package/dist/plugin-management-service.js

@@ -0,0 +1,240 @@
+import { randomBytes } from "node:crypto";
+import { PLUGIN_ID_PATTERN } from "@rynx-ai/plugin-sdk";
+import { preparePluginInstallation, uninstallPlugin, } from "./plugin-installer.js";
+import { getPlugin, isRunnablePluginRecord, listPlugins, setPluginEnabled, } from "./plugin-store.js";
+const defaultDependencies = {
+    list: listPlugins,
+    get: getPlugin,
+    setEnabled: setPluginEnabled,
+    uninstall: (id) => uninstallPlugin(id),
+    prepare: preparePluginInstallation,
+};
+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.
+ */
+export class PluginManagementService {
+    dependencies;
+    pending = new Map();
+    now;
+    token;
+    schedule;
+    preparationTtlMs;
+    constructor(dependencies = defaultDependencies, options = {}) {
+        this.dependencies = dependencies;
+        this.preparationTtlMs = options.preparationTtlMs ?? DEFAULT_PREPARATION_TTL_MS;
+        if (!Number.isSafeInteger(this.preparationTtlMs) || this.preparationTtlMs <= 0) {
+            throw new Error("plugin preparation TTL must be a positive safe integer");
+        }
+        this.now = options.now ?? Date.now;
+        this.token = options.token ?? (() => randomBytes(32).toString("base64url"));
+        this.schedule = options.schedule ?? setTimeout;
+    }
+    list() {
+        return { plugins: this.dependencies.list().map(toManagementItem) };
+    }
+    setEnabled(id, enabled) {
+        validatePluginId(id);
+        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"}`);
+        }
+        this.dependencies.setEnabled(id, enabled);
+        const updated = this.dependencies.get(id);
+        if (!updated) {
+            throw new Error(`plugin "${id}" disappeared while updating its state`);
+        }
+        return toManagementItem(updated);
+    }
+    async uninstall(id) {
+        validatePluginId(id);
+        return this.dependencies.uninstall(id);
+    }
+    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");
+            spec = input.spec;
+        }
+        else {
+            if (!input.pluginId)
+                throw new Error("plugin update id is required");
+            validatePluginId(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`);
+            }
+            spec = existing.spec;
+            expectedId = existing.name;
+        }
+        const prepared = await this.dependencies.prepare(spec, () => { }, {
+            allowScripts: input.allowScripts,
+            ...(expectedId ? { expectedId } : {}),
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        try {
+            options.signal?.throwIfAborted();
+            const token = this.uniqueToken();
+            const expiresAtMs = this.now() + this.preparationTtlMs;
+            const expiryTimer = this.schedule(() => {
+                const current = this.pending.get(token);
+                if (!current || current.prepared !== prepared)
+                    return;
+                this.pending.delete(token);
+                current.prepared.discard();
+            }, this.preparationTtlMs);
+            expiryTimer.unref?.();
+            this.pending.set(token, { prepared, expiresAtMs, expiryTimer });
+            return toInstallPreparation(token, expiresAtMs, prepared);
+        }
+        catch (error) {
+            prepared.discard();
+            throw error;
+        }
+    }
+    async commitInstallation(token, input, options = {}) {
+        const pending = this.takePreparation(token);
+        if (!pending)
+            throw invalidPreparationError();
+        clearTimeout(pending.expiryTimer);
+        if (this.now() >= pending.expiresAtMs) {
+            pending.prepared.discard();
+            throw invalidPreparationError();
+        }
+        const { prepared } = pending;
+        try {
+            options.signal?.throwIfAborted();
+            if (input.expectedDigest !== prepared.integrity) {
+                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`);
+            }
+            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) };
+        }
+        finally {
+            prepared.discard();
+        }
+    }
+    cancelPreparation(token) {
+        const pending = this.takePreparation(token);
+        if (!pending)
+            return false;
+        clearTimeout(pending.expiryTimer);
+        pending.prepared.discard();
+        return true;
+    }
+    dispose() {
+        for (const [token, pending] of this.pending) {
+            this.pending.delete(token);
+            clearTimeout(pending.expiryTimer);
+            pending.prepared.discard();
+        }
+    }
+    takePreparation(token) {
+        if (!/^[A-Za-z0-9_-]{32,128}$/.test(token))
+            return undefined;
+        const pending = this.pending.get(token);
+        if (pending)
+            this.pending.delete(token);
+        return pending;
+    }
+    uniqueToken() {
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            const token = this.token();
+            if (/^[A-Za-z0-9_-]{32,128}$/.test(token) && !this.pending.has(token))
+                return token;
+        }
+        throw new Error("failed to allocate a plugin preparation token");
+    }
+}
+function toManagementItem(record) {
+    const runnable = isRunnablePluginRecord(record);
+    return {
+        id: record.name,
+        ...(record.version ? { 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],
+        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 } : {}),
+            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],
+                },
+            }
+            : {}),
+        capabilityDiff: {
+            added: requested.filter((capability) => !priorSet.has(capability)),
+            retained: requested.filter((capability) => priorSet.has(capability)),
+            removed: prior.filter((capability) => !requestedSet.has(capability)),
+        },
+    };
+}
+function managementState(record) {
+    return !isRunnablePluginRecord(record)
+        ? "reinstall-required"
+        : record.enabled
+            ? "enabled"
+            : "disabled";
+}
+function invalidPreparationError() {
+    return new Error("plugin installation preparation is invalid or expired");
+}
+function validatePluginId(id) {
+    if (!PLUGIN_ID_PATTERN.test(id))
+        throw new Error("invalid plugin id");
+}

package/dist/plugin-package.d.ts

@@ -1,5 +1,18 @@
 import { type PluginManifestV1 } from "@rynx-ai/plugin-sdk";
 import type { PluginSource } from "./plugin-store.js";
+export interface PluginPackageInspectionLimits {
+    maxFileBytes: number;
+    maxTotalBytes: number;
+    maxEntries: number;
+    maxDepth: number;
+}
+export declare const DEFAULT_PLUGIN_PACKAGE_INSPECTION_LIMITS: Readonly<PluginPackageInspectionLimits>;
+export interface InspectPluginPackageOptions {
+    requireEntries?: boolean;
+    signal?: AbortSignal;
+    /** Test/internal override; daemon installation always uses the safe defaults. */
+    limits?: Partial<PluginPackageInspectionLimits>;
+}
 export interface MaterializePluginPackageRequest {
     spec: string;
     source: PluginSource;
@@ -31,8 +44,18 @@ export declare function parseGitSpec(spec: string): {
     ref?: string;
 };
 /** Parse and validate static metadata, validate all executable entry paths, and hash the tree. */
-export declare function inspectPluginPackage(packageDir: string, options?: {
-    requireEntries?: boolean;
-}): InspectedPluginPackage;
+export declare function inspectPluginPackage(packageDir: string, options?: InspectPluginPackageOptions): Promise<InspectedPluginPackage>;
 /** Run package/dependency build scripts only after explicit user approval. */
 export declare function rebuildPluginPackage(packageDir: string, onProgress: (line: string) => void, signal?: AbortSignal): Promise<void>;
+export interface RunPluginPackageCommandOptions {
+    signal?: AbortSignal;
+    cwd?: string;
+    /** Internal/test override; production uses a bounded two-second grace. */
+    abortGraceMs?: number;
+}
+/**
+ * Run one package tool without a shell and tear down its full POSIX process
+ * group on cancellation. Windows cannot signal process groups through Node,
+ * so it safely degrades to TERM→KILL on the direct child.
+ */
+export declare function runPluginPackageCommand(command: string, args: string[], onProgress: (line: string) => void, options?: RunPluginPackageCommandOptions): Promise<void>;