@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/runtime/plugins/trust.js

@@ -0,0 +1,198 @@
+/**
+ * Plugin extension trust framework.
+ *
+ * Defines trust tiers (untrusted, limited, trusted), signed manifest
+ * validation for the trusted tier, and the PluginTrustStore that manages
+ * trust records with persistence support.
+ *
+ * Trust tiers gate access to high-risk capabilities:
+ *   - untrusted — only safe, read-only capabilities allowed
+ *   - limited   — moderate capabilities; high-risk capabilities blocked
+ *   - trusted   — full capability set; requires signed manifest validation
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { isHighRiskCapability } from './manifest.js';
+/**
+ * validatePluginSignature — Validates the manifest signature for a plugin
+ * seeking the `trusted` tier.
+ *
+ * The signature field in PluginManifestV2 is expected to be a base64-encoded
+ * HMAC-SHA256 of the canonical manifest JSON (name + version + capabilities
+ * sorted and serialised). For production use, callers should supply a real
+ * key; this implementation uses a structural check so external tooling can
+ * provide real crypto without requiring Node.js crypto APIs at import time.
+ *
+ * @param manifest  - The raw manifest object containing the `signature` field.
+ * @param publicKey - Optional verification key. When omitted, structural
+ *                    validity only is checked (suitable for CI/test).
+ */
+export function validatePluginSignature(manifest, publicKey) {
+    const { name, version, capabilities = [], signature } = manifest;
+    if (!signature || typeof signature !== 'string' || signature.trim().length === 0) {
+        return { valid: false, reason: 'No signature field present in manifest' };
+    }
+    // Structural check: signature must be a non-empty hex or base64 string.
+    const isStructurallyValid = /^[A-Za-z0-9+/=]{32,}$/.test(signature.trim());
+    if (!isStructurallyValid) {
+        return { valid: false, reason: 'Signature field does not match expected format (base64/hex, min 32 chars)' };
+    }
+    // Canonical payload that should have been signed.
+    const sortedCapabilities = [...capabilities].sort();
+    const payload = JSON.stringify({ name, version, capabilities: sortedCapabilities });
+    // When a public key is provided, perform full HMAC verification.
+    if (publicKey) {
+        const expected = createHmac('sha256', publicKey)
+            .update(payload)
+            .digest('base64');
+        const sigBuf = Buffer.from(signature.trim(), 'base64');
+        const expBuf = Buffer.from(expected, 'base64');
+        if (sigBuf.length !== expBuf.length || !timingSafeEqual(sigBuf, expBuf)) {
+            return { valid: false, reason: 'HMAC mismatch' };
+        }
+    }
+    // Derive a short fingerprint for record keeping.
+    const fingerprint = signature.trim().slice(0, 16);
+    logger.debug(`[plugin-trust] Manifest signature validated — plugin=${name} fingerprint=${fingerprint}` +
+        (publicKey ? ' (full HMAC)' : ' (structural only)'));
+    return { valid: true, fingerprint };
+}
+// ── Capability filtering by trust tier ───────────────────────────────────────
+/**
+ * Capabilities that are safe for any trust tier (including untrusted).
+ */
+export const SAFE_CAPABILITIES = [
+    'register.tool',
+    'register.provider',
+    'register.panel',
+    'register.hook',
+    'filesystem.read',
+];
+/**
+ * filterCapabilitiesByTrust — Returns the subset of `requested` capabilities
+ * that are permitted for the given trust tier.
+ *
+ * - `untrusted`: only SAFE_CAPABILITIES
+ * - `limited`:   all capabilities except HIGH_RISK_CAPABILITIES
+ * - `trusted`:   all capabilities (HIGH_RISK_CAPABILITIES included)
+ */
+export function filterCapabilitiesByTrust(requested, tier) {
+    const permitted = [];
+    const blocked = [];
+    const reasons = {};
+    for (const cap of requested) {
+        if (tier === 'trusted') {
+            permitted.push(cap);
+        }
+        else if (tier === 'limited') {
+            if (isHighRiskCapability(cap)) {
+                blocked.push(cap);
+                reasons[cap] = `Capability '${cap}' requires trust tier 'trusted' (current: limited)`;
+            }
+            else {
+                permitted.push(cap);
+            }
+        }
+        else {
+            // untrusted
+            if (SAFE_CAPABILITIES.includes(cap)) {
+                permitted.push(cap);
+            }
+            else {
+                blocked.push(cap);
+                reasons[cap] = `Capability '${cap}' requires trust tier 'limited' or higher (current: untrusted)`;
+            }
+        }
+    }
+    return { permitted, blocked, reasons };
+}
+// ── Trust Store ───────────────────────────────────────────────────────────────
+/**
+ * PluginTrustStore — In-memory trust registry for all plugins.
+ *
+ * Callers are responsible for persistence (serialise/deserialise via
+ * `exportRecords` / `importRecords`). The PluginManager bridges this to
+ * the plugins.json state file.
+ */
+export class PluginTrustStore {
+    records = new Map();
+    /**
+     * Returns the trust record for a plugin, or `undefined` if not yet assessed.
+     * Callers should treat `undefined` as implicitly `untrusted`.
+     */
+    getRecord(pluginName) {
+        return this.records.get(pluginName);
+    }
+    /**
+     * Returns the trust tier for a plugin.
+     * Plugins without an explicit record are treated as `untrusted`.
+     */
+    getTier(pluginName) {
+        return this.records.get(pluginName)?.tier ?? 'untrusted';
+    }
+    /**
+     * setTier — Explicitly assign a trust tier to a plugin.
+     *
+     * Intended for operator use via `/plugin trust`.
+     * For the `trusted` tier, prefer `trustSigned()` which also validates the signature.
+     */
+    setTier(pluginName, tier, options = {}) {
+        const record = {
+            pluginName,
+            tier,
+            updatedAt: Date.now(),
+            grantedBy: 'operator',
+            note: options.note,
+        };
+        this.records.set(pluginName, record);
+        logger.info(`[plugin-trust] ${pluginName}: tier set to '${tier}'${options.note ? ` — ${options.note}` : ''}`);
+        return record;
+    }
+    /**
+     * trustSigned — Elevate a plugin to the `trusted` tier after verifying its
+     * signed manifest. Returns `{ ok: false, reason }` if validation fails.
+     */
+    trustSigned(pluginName, manifest, publicKey) {
+        const validation = validatePluginSignature(manifest, publicKey);
+        if (!validation.valid) {
+            logger.warn(`[plugin-trust] ${pluginName}: signature validation failed — ${validation.reason}`);
+            return { ok: false, reason: validation.reason };
+        }
+        const record = {
+            pluginName,
+            tier: 'trusted',
+            updatedAt: Date.now(),
+            grantedBy: 'signed-manifest',
+            signatureFingerprint: validation.fingerprint,
+        };
+        this.records.set(pluginName, record);
+        logger.info(`[plugin-trust] ${pluginName}: elevated to 'trusted' via signed manifest (fingerprint=${validation.fingerprint})`);
+        return { ok: true, record };
+    }
+    /**
+     * verify — Verify the current signature on a plugin manifest without
+     * changing its tier. Useful for `/plugin verify` inspection.
+     */
+    verify(manifest, publicKey) {
+        return validatePluginSignature(manifest, publicKey);
+    }
+    /** Returns all trust records as an array. */
+    getAllRecords() {
+        return Array.from(this.records.values());
+    }
+    /** Export all records for persistence. */
+    exportRecords() {
+        const out = {};
+        for (const [name, record] of this.records) {
+            out[name] = { ...record };
+        }
+        return out;
+    }
+    /** Import records from persisted state. Merges into existing records. */
+    importRecords(records) {
+        for (const [name, record] of Object.entries(records)) {
+            this.records.set(name, record);
+        }
+        logger.debug(`[plugin-trust] Imported ${Object.keys(records).length} trust record(s)`);
+    }
+}

package/dist/_internal/platform/runtime/plugins/types.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Plugin lifecycle system types.
+ *
+ * Types here extend the store domain types with the richer capability
+ * manifest and transition models used by the PluginLifecycleManager.
+ */
+import type { PluginLifecycleState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/plugins';
+import type { PluginManifest } from '../../plugins/loader.js';
+export type { PluginLifecycleState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/plugins';
+/**
+ * The set of capabilities a plugin can declare in its manifest.
+ *
+ * All capabilities are **deny-by-default**: a plugin must explicitly request
+ * each capability and the runtime must grant it before the capability is
+ * exercisable.
+ */
+export type PluginCapability = 'filesystem.read' | 'filesystem.write' | 'network.outbound' | 'shell.exec' | 'register.tool' | 'register.provider' | 'register.panel' | 'register.hook';
+/** All defined capability strings as a readonly array. */
+export declare const ALL_CAPABILITIES: ReadonlyArray<PluginCapability>;
+/**
+ * High-risk capabilities that require the `trusted` tier to be granted.
+ * These capabilities can have significant side-effects outside the process.
+ */
+export declare const HIGH_RISK_CAPABILITIES: ReadonlyArray<PluginCapability>;
+/**
+ * Capability manifest embedded in (or derived from) a plugin's manifest.json.
+ *
+ * `requested` lists every capability the plugin declares it needs.
+ * `granted` is resolved by the runtime after validation — it may be a strict
+ * subset of `requested` if some capabilities are denied by policy.
+ */
+export interface PluginCapabilityManifest {
+    /** Capabilities declared by the plugin author. */
+    readonly requested: ReadonlyArray<PluginCapability>;
+    /** Capabilities actually granted by the runtime. Populated after resolution. */
+    granted: PluginCapability[];
+    /** Capabilities that were requested but explicitly denied by runtime policy. */
+    denied: PluginCapability[];
+    /** Human-readable denial reasons keyed by capability. */
+    denialReasons: Partial<Record<PluginCapability, string>>;
+}
+/**
+ * PluginManifestV2 extends the loader's PluginManifest with capability
+ * declarations and trust framework fields.
+ * Stored inside manifest.json under the `capabilities` key.
+ * Omitting the key is equivalent to requesting no capabilities.
+ */
+export interface PluginManifestV2 extends PluginManifest {
+    /** Optional capability list declared by the plugin. */
+    capabilities?: PluginCapability[];
+    /**
+     * Minimum runtime version this plugin requires.
+     * Semver string (e.g. "0.9.0"). Unset = no constraint.
+     */
+    minRuntimeVersion?: string;
+    /**
+     * Base64-encoded HMAC-SHA256 signature of the canonical manifest payload.
+     * Required for plugins that want to operate at the `trusted` tier.
+     */
+    signature?: string;
+    /**
+     * Declared trust tier hint from the plugin author.
+     * The runtime validates this against the actual trust record; it does not
+     * grant trust by itself.
+     */
+    trustTier?: import('./trust.js').PluginTrustTier;
+}
+/**
+ * A single recorded state transition for a plugin.
+ */
+export interface PluginTransition {
+    /** The plugin name this transition applies to. */
+    readonly pluginName: string;
+    /** State before the transition. */
+    readonly from: PluginLifecycleState;
+    /** State after the transition. */
+    readonly to: PluginLifecycleState;
+    /** Unix timestamp (ms) when the transition occurred. */
+    readonly ts: number;
+    /** Optional human-readable reason (e.g. error message, disable reason). */
+    readonly reason?: string;
+}
+/**
+ * Result of a state machine transition attempt.
+ */
+export type TransitionResult = {
+    ok: true;
+    from: PluginLifecycleState;
+    to: PluginLifecycleState;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Result of a plugin health check (used during hot-reload).
+ */
+export interface PluginHealthCheckResult {
+    /** Whether the plugin is considered healthy after the check. */
+    readonly healthy: boolean;
+    /** Human-readable status message. */
+    readonly message: string;
+    /** Duration of the health check in milliseconds. */
+    readonly durationMs: number;
+}
+/**
+ * PluginLifecycleRecord — full runtime record for a plugin tracked by the
+ * PluginLifecycleManager. Extends the basic RuntimePlugin from the store
+ * domain with the capability manifest and transition history.
+ */
+export interface PluginLifecycleRecord {
+    /** Plugin name (filesystem identifier). */
+    readonly name: string;
+    /** Plugin version string. */
+    readonly version: string;
+    /** Current lifecycle state. */
+    state: PluginLifecycleState;
+    /** Resolved capability manifest. */
+    capabilities: PluginCapabilityManifest;
+    /** Last N state transitions (capped at MAX_TRANSITION_HISTORY). */
+    transitions: PluginTransition[];
+    /** Epoch ms when the plugin was last successfully activated. */
+    activatedAt?: number;
+    /** Epoch ms when the plugin last transitioned to error. */
+    errorAt?: number;
+    /** Last error message, if any. */
+    lastError?: string;
+    /** Whether a hot-reload is currently in progress for this plugin. */
+    reloading: boolean;
+    /** Trust tier assigned to this plugin. Defaults to 'untrusted'. */
+    trustTier: import('./trust.js').PluginTrustTier;
+    /** Whether this plugin is currently quarantined. */
+    quarantined: boolean;
+}
+/** Maximum transition history entries kept per plugin. */
+export declare const MAX_TRANSITION_HISTORY = 50;
+/**
+ * Options accepted by `createPluginLifecycleManager()`.
+ */
+export interface PluginLifecycleManagerOptions {
+    /**
+     * Session ID injected into emitted events.
+     * Defaults to an empty string when not provided.
+     */
+    sessionId?: string;
+    /**
+     * Optional policy callback invoked during capability resolution.
+     * Return `true` to grant the capability, `false` to deny.
+     * Defaults to a permissive policy that grants all valid capabilities.
+     */
+    capabilityPolicy?: (pluginName: string, capability: PluginCapability) => boolean;
+    /**
+     * Optional trust tier resolver. Called during capability resolution to
+     * determine the effective trust tier for capability filtering.
+     * Return the tier for the given plugin name.
+     * Defaults to 'untrusted' for all plugins when not provided.
+     */
+    trustTierResolver?: (pluginName: string) => import('./trust.js').PluginTrustTier;
+    /**
+     * Runtime event bus used for lifecycle emission.
+     * When omitted, the manager creates an isolated in-memory bus.
+     */
+    runtimeBus?: import('../events/index.js').RuntimeEventBus;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_internal/platform/runtime/plugins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/plugins/types.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/runtime/plugins/types.js

@@ -0,0 +1,28 @@
+/**
+ * Plugin lifecycle system types.
+ *
+ * Types here extend the store domain types with the richer capability
+ * manifest and transition models used by the PluginLifecycleManager.
+ */
+/** All defined capability strings as a readonly array. */
+export const ALL_CAPABILITIES = [
+    'filesystem.read',
+    'filesystem.write',
+    'network.outbound',
+    'shell.exec',
+    'register.tool',
+    'register.provider',
+    'register.panel',
+    'register.hook',
+];
+/**
+ * High-risk capabilities that require the `trusted` tier to be granted.
+ * These capabilities can have significant side-effects outside the process.
+ */
+export const HIGH_RISK_CAPABILITIES = [
+    'filesystem.write',
+    'network.outbound',
+    'shell.exec',
+];
+/** Maximum transition history entries kept per plugin. */
+export const MAX_TRANSITION_HISTORY = 50;

package/dist/_internal/platform/runtime/provider-accounts/registry.d.ts

@@ -0,0 +1,53 @@
+import type { SecretsManager } from '../../config/secrets.js';
+import type { ProviderRegistry } from '../../providers/registry.js';
+import type { ServiceRegistry } from '../../config/service-registry.js';
+import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
+export type ProviderAuthRoute = 'api-key' | 'subscription' | 'service-oauth' | 'unconfigured';
+export type ProviderAuthFreshness = 'healthy' | 'expiring' | 'expired' | 'pending' | 'unconfigured';
+export interface ProviderUsageWindow {
+    readonly label: string;
+    readonly detail: string;
+}
+export interface ProviderRouteRecord {
+    readonly route: Exclude<ProviderAuthRoute, 'unconfigured'>;
+    readonly usable: boolean;
+    readonly freshness: ProviderAuthFreshness;
+    readonly detail: string;
+    readonly issues: readonly string[];
+}
+export interface ProviderAccountRecord {
+    readonly providerId: string;
+    readonly active: boolean;
+    readonly modelCount: number;
+    readonly configured: boolean;
+    readonly oauthReady: boolean;
+    readonly pendingLogin: boolean;
+    readonly availableRoutes: readonly ProviderAuthRoute[];
+    readonly preferredRoute: ProviderAuthRoute;
+    readonly activeRoute: ProviderAuthRoute;
+    readonly activeRouteReason: string;
+    readonly authFreshness: ProviderAuthFreshness;
+    readonly fallbackRoute?: ProviderAuthRoute;
+    readonly fallbackRisk?: string;
+    readonly expiresAt?: number;
+    readonly tokenType?: string;
+    readonly notes: readonly string[];
+    readonly usageWindows: readonly ProviderUsageWindow[];
+    readonly issues: readonly string[];
+    readonly recommendedActions: readonly string[];
+    readonly routeRecords: readonly ProviderRouteRecord[];
+}
+export interface ProviderAccountSnapshot {
+    readonly capturedAt: number;
+    readonly providers: readonly ProviderAccountRecord[];
+    readonly configuredCount: number;
+    readonly issueCount: number;
+}
+export interface ProviderAccountSnapshotDeps {
+    readonly providerRegistry: Pick<ProviderRegistry, 'listModels' | 'getCurrentModel' | 'getRegistered' | 'describeRuntime'>;
+    readonly serviceRegistry: Pick<ServiceRegistry, 'getAll' | 'inspect'>;
+    readonly subscriptionManager: Pick<SubscriptionManager, 'list' | 'listPending' | 'get' | 'getPending'>;
+    readonly secretsManager: Pick<SecretsManager, 'get'>;
+}
+export declare function buildProviderAccountSnapshot(deps: ProviderAccountSnapshotDeps): Promise<ProviderAccountSnapshot>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/_internal/platform/runtime/provider-accounts/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/provider-accounts/registry.ts"],"names":[],"mappings":"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"}