@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

package/dist/plugins/management.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Plugin management — install, uninstall, enable, disable, and list plugins
+ * with persistent state stored in a configurable directory (GAP-USER-017).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+// ---------------------------------------------------------------------------
+// PluginManager
+// ---------------------------------------------------------------------------
+const STATE_FILENAME = 'plugins-state.json';
+class PluginManager {
+    stateDir;
+    statePath;
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+        this.statePath = (0, node_path_1.join)(stateDir, STATE_FILENAME);
+    }
+    /** List all known plugins. */
+    list() {
+        const state = this.readState();
+        return Object.values(state.plugins);
+    }
+    /** Install a plugin by id. Marks it as installed and enabled. */
+    install(id) {
+        const state = this.readState();
+        const existing = state.plugins[id];
+        if (existing?.installed) {
+            return existing;
+        }
+        const info = existing
+            ? { ...existing, installed: true, enabled: true }
+            : {
+                id,
+                name: id,
+                version: '0.0.0',
+                trustLevel: 'untrusted',
+                installed: true,
+                enabled: true,
+            };
+        state.plugins[id] = info;
+        this.writeState(state);
+        return info;
+    }
+    /** Uninstall a plugin by id. */
+    uninstall(id) {
+        const state = this.readState();
+        const existing = state.plugins[id];
+        if (!existing)
+            return;
+        existing.installed = false;
+        existing.enabled = false;
+        this.writeState(state);
+    }
+    /** Enable an installed plugin. */
+    enable(id) {
+        const state = this.readState();
+        const existing = state.plugins[id];
+        if (!existing || !existing.installed) {
+            throw new Error(`Plugin "${id}" is not installed`);
+        }
+        existing.enabled = true;
+        this.writeState(state);
+    }
+    /** Disable an installed plugin (keeps it installed). */
+    disable(id) {
+        const state = this.readState();
+        const existing = state.plugins[id];
+        if (!existing || !existing.installed) {
+            throw new Error(`Plugin "${id}" is not installed`);
+        }
+        existing.enabled = false;
+        this.writeState(state);
+    }
+    /** Get info for a single plugin, or undefined if unknown. */
+    getInfo(id) {
+        const state = this.readState();
+        return state.plugins[id];
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    readState() {
+        if (!(0, node_fs_1.existsSync)(this.statePath)) {
+            return { plugins: {} };
+        }
+        const raw = (0, node_fs_1.readFileSync)(this.statePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    writeState(state) {
+        if (!(0, node_fs_1.existsSync)(this.stateDir)) {
+            (0, node_fs_1.mkdirSync)(this.stateDir, { recursive: true });
+        }
+        (0, node_fs_1.writeFileSync)(this.statePath, JSON.stringify(state, null, 2), 'utf-8');
+    }
+}
+exports.PluginManager = PluginManager;

package/dist/plugins/marketplace.d.ts

@@ -0,0 +1,64 @@
+/**
+ * CC Marketplace Protocol Support (GAP-ECO-002).
+ *
+ * Client and installer for the babysitter plugin marketplace.
+ * Uses injectable fetch for testability — no actual HTTP calls
+ * are hard-wired.
+ */
+export interface MarketplaceEntry {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    downloadUrl: string;
+    checksumSha256: string;
+    category?: string;
+}
+export interface MarketplaceSearchResult {
+    entries: MarketplaceEntry[];
+    total: number;
+}
+export interface MarketplaceCategoryList {
+    categories: string[];
+}
+/** Minimal fetch interface for dependency injection. */
+export type FetchFn = (url: string, init?: {
+    method?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}>;
+export declare class MarketplaceClient {
+    private readonly baseUrl;
+    private readonly fetch;
+    constructor(baseUrl: string, fetch: FetchFn);
+    /**
+     * Search the marketplace by query string.
+     */
+    search(query: string): Promise<MarketplaceSearchResult>;
+    /**
+     * Get a single marketplace entry by id.
+     */
+    getEntry(id: string): Promise<MarketplaceEntry>;
+    /**
+     * List all available categories.
+     */
+    listCategories(): Promise<string[]>;
+}
+export declare class MarketplaceInstaller {
+    private readonly fetch;
+    constructor(fetch: FetchFn);
+    /**
+     * Download and install a marketplace entry to the target directory.
+     * Returns the path where the plugin was installed.
+     */
+    install(entry: MarketplaceEntry, targetDir: string): Promise<string>;
+    /**
+     * Verify an installed plugin matches its expected checksum.
+     */
+    verify(entry: MarketplaceEntry, installedPath: string): boolean;
+}
+//# sourceMappingURL=marketplace.d.ts.map

package/dist/plugins/marketplace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace.d.ts","sourceRoot":"","sources":["../../src/plugins/marketplace.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,wDAAwD;AACxD,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC;IACzE,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACzB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB,CAAC,CAAC;AAMH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;gBADL,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO;IAGjC;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAS7D;;OAEG;IACG,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IASrD;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAS1C;AAMD,qBAAa,oBAAoB;IACnB,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,OAAO;IAE3C;;;OAGG;IACG,OAAO,CAAC,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB1E;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO;CAQhE"}

package/dist/plugins/marketplace.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * CC Marketplace Protocol Support (GAP-ECO-002).
+ *
+ * Client and installer for the babysitter plugin marketplace.
+ * Uses injectable fetch for testability — no actual HTTP calls
+ * are hard-wired.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketplaceInstaller = exports.MarketplaceClient = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+// ---------------------------------------------------------------------------
+// MarketplaceClient
+// ---------------------------------------------------------------------------
+class MarketplaceClient {
+    baseUrl;
+    fetch;
+    constructor(baseUrl, fetch) {
+        this.baseUrl = baseUrl;
+        this.fetch = fetch;
+    }
+    /**
+     * Search the marketplace by query string.
+     */
+    async search(query) {
+        const url = `${this.baseUrl}/search?q=${encodeURIComponent(query)}`;
+        const res = await this.fetch(url);
+        if (!res.ok) {
+            throw new Error(`Marketplace search failed: HTTP ${res.status}`);
+        }
+        return (await res.json());
+    }
+    /**
+     * Get a single marketplace entry by id.
+     */
+    async getEntry(id) {
+        const url = `${this.baseUrl}/entries/${encodeURIComponent(id)}`;
+        const res = await this.fetch(url);
+        if (!res.ok) {
+            throw new Error(`Marketplace getEntry failed: HTTP ${res.status}`);
+        }
+        return (await res.json());
+    }
+    /**
+     * List all available categories.
+     */
+    async listCategories() {
+        const url = `${this.baseUrl}/categories`;
+        const res = await this.fetch(url);
+        if (!res.ok) {
+            throw new Error(`Marketplace listCategories failed: HTTP ${res.status}`);
+        }
+        const data = (await res.json());
+        return data.categories;
+    }
+}
+exports.MarketplaceClient = MarketplaceClient;
+// ---------------------------------------------------------------------------
+// MarketplaceInstaller
+// ---------------------------------------------------------------------------
+class MarketplaceInstaller {
+    fetch;
+    constructor(fetch) {
+        this.fetch = fetch;
+    }
+    /**
+     * Download and install a marketplace entry to the target directory.
+     * Returns the path where the plugin was installed.
+     */
+    async install(entry, targetDir) {
+        const res = await this.fetch(entry.downloadUrl);
+        if (!res.ok) {
+            throw new Error(`Download failed for ${entry.id}: HTTP ${res.status}`);
+        }
+        const content = await res.text();
+        if (!(0, node_fs_1.existsSync)(targetDir)) {
+            (0, node_fs_1.mkdirSync)(targetDir, { recursive: true });
+        }
+        const pluginDir = (0, node_path_1.join)(targetDir, entry.id);
+        if (!(0, node_fs_1.existsSync)(pluginDir)) {
+            (0, node_fs_1.mkdirSync)(pluginDir, { recursive: true });
+        }
+        const manifestPath = (0, node_path_1.join)(pluginDir, 'plugin.json');
+        (0, node_fs_1.writeFileSync)(manifestPath, content, 'utf8');
+        return pluginDir;
+    }
+    /**
+     * Verify an installed plugin matches its expected checksum.
+     */
+    verify(entry, installedPath) {
+        const manifestPath = (0, node_path_1.join)(installedPath, 'plugin.json');
+        if (!(0, node_fs_1.existsSync)(manifestPath))
+            return false;
+        const content = (0, node_fs_1.readFileSync)(manifestPath, 'utf8');
+        const hash = (0, node_crypto_1.createHash)('sha256').update(content).digest('hex');
+        return hash === entry.checksumSha256;
+    }
+}
+exports.MarketplaceInstaller = MarketplaceInstaller;

package/dist/plugins/sandbox.d.ts

@@ -0,0 +1,38 @@
+/**
+ * PluginSandbox — permission tracking and policy enforcement for loaded plugins.
+ *
+ * Each plugin is assigned a set of permissions drawn from its manifest.
+ * Runtime checks gate access to resources (file paths, network, shell, etc.)
+ * by combining the granted permissions with an optional PluginSandboxConfig.
+ */
+import type { PluginPermission, PluginSandboxConfig } from './types';
+export declare class PluginSandbox {
+    private permissions;
+    private configs;
+    /** Grant a single permission to a plugin. */
+    grantPermission(pluginId: string, permission: PluginPermission): void;
+    /** Revoke a single permission from a plugin. */
+    revokePermission(pluginId: string, permission: PluginPermission): void;
+    /** Check whether a plugin currently holds a given permission. */
+    checkPermission(pluginId: string, permission: PluginPermission): boolean;
+    /** Return the full list of permissions granted to a plugin. */
+    getPermissions(pluginId: string): PluginPermission[];
+    /** Attach a sandbox configuration (memory / timeout / allowed paths) for a plugin. */
+    setConfig(pluginId: string, config: PluginSandboxConfig): void;
+    /** Retrieve the sandbox configuration for a plugin, if any. */
+    getConfig(pluginId: string): PluginSandboxConfig | undefined;
+    /**
+     * Determine whether a plugin is allowed to perform `action` on `resource`.
+     *
+     * The check works in two stages:
+     * 1. The action is mapped to a required permission. If the plugin does not
+     *    hold that permission the call is denied.
+     * 2. For file-system actions the optional `allowedPaths` list in the sandbox
+     *    config is consulted. If the list exists and the resource does not start
+     *    with any allowed prefix the call is denied.
+     */
+    isAllowed(pluginId: string, action: string, resource?: string): boolean;
+    /** Remove all permission and config state for a plugin. */
+    clear(pluginId: string): void;
+}
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/plugins/sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../src/plugins/sandbox.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAarE,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAA4C;IAC/D,OAAO,CAAC,OAAO,CAA0C;IAMzD,6CAA6C;IAC7C,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,IAAI;IASrE,gDAAgD;IAChD,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAOtE,iEAAiE;IACjE,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO;IAIxE,+DAA+D;IAC/D,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE;IASpD,sFAAsF;IACtF,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,IAAI;IAI9D,+DAA+D;IAC/D,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAQ5D;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO;IAoCvE,2DAA2D;IAC3D,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAI9B"}

package/dist/plugins/sandbox.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * PluginSandbox — permission tracking and policy enforcement for loaded plugins.
+ *
+ * Each plugin is assigned a set of permissions drawn from its manifest.
+ * Runtime checks gate access to resources (file paths, network, shell, etc.)
+ * by combining the granted permissions with an optional PluginSandboxConfig.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginSandbox = void 0;
+/** Map from a high-level action verb to the permission(s) it requires. */
+const ACTION_PERMISSION_MAP = {
+    read: 'fs:read',
+    write: 'fs:write',
+    fetch: 'net:outbound',
+    spawn: 'process:spawn',
+    env: 'env:read',
+    mcp: 'mcp:connect',
+    shell: 'shell:execute',
+};
+class PluginSandbox {
+    permissions = new Map();
+    configs = new Map();
+    // ---------------------------------------------------------------------------
+    // Permission CRUD
+    // ---------------------------------------------------------------------------
+    /** Grant a single permission to a plugin. */
+    grantPermission(pluginId, permission) {
+        let perms = this.permissions.get(pluginId);
+        if (!perms) {
+            perms = new Set();
+            this.permissions.set(pluginId, perms);
+        }
+        perms.add(permission);
+    }
+    /** Revoke a single permission from a plugin. */
+    revokePermission(pluginId, permission) {
+        const perms = this.permissions.get(pluginId);
+        if (perms) {
+            perms.delete(permission);
+        }
+    }
+    /** Check whether a plugin currently holds a given permission. */
+    checkPermission(pluginId, permission) {
+        return this.permissions.get(pluginId)?.has(permission) ?? false;
+    }
+    /** Return the full list of permissions granted to a plugin. */
+    getPermissions(pluginId) {
+        const perms = this.permissions.get(pluginId);
+        return perms ? [...perms] : [];
+    }
+    // ---------------------------------------------------------------------------
+    // Configuration
+    // ---------------------------------------------------------------------------
+    /** Attach a sandbox configuration (memory / timeout / allowed paths) for a plugin. */
+    setConfig(pluginId, config) {
+        this.configs.set(pluginId, config);
+    }
+    /** Retrieve the sandbox configuration for a plugin, if any. */
+    getConfig(pluginId) {
+        return this.configs.get(pluginId);
+    }
+    // ---------------------------------------------------------------------------
+    // Policy check
+    // ---------------------------------------------------------------------------
+    /**
+     * Determine whether a plugin is allowed to perform `action` on `resource`.
+     *
+     * The check works in two stages:
+     * 1. The action is mapped to a required permission. If the plugin does not
+     *    hold that permission the call is denied.
+     * 2. For file-system actions the optional `allowedPaths` list in the sandbox
+     *    config is consulted. If the list exists and the resource does not start
+     *    with any allowed prefix the call is denied.
+     */
+    isAllowed(pluginId, action, resource) {
+        // Resolve the permission required for this action
+        const requiredPermission = ACTION_PERMISSION_MAP[action];
+        if (!requiredPermission) {
+            // Unknown action — deny by default
+            return false;
+        }
+        if (!this.checkPermission(pluginId, requiredPermission)) {
+            return false;
+        }
+        // For filesystem operations, enforce allowedPaths when configured
+        if (resource &&
+            (requiredPermission === 'fs:read' || requiredPermission === 'fs:write')) {
+            const config = this.configs.get(pluginId);
+            if (config?.allowedPaths && config.allowedPaths.length > 0) {
+                const normalised = resource.replace(/\\/g, '/');
+                const allowed = config.allowedPaths.some((p) => normalised.startsWith(p.replace(/\\/g, '/')));
+                if (!allowed) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    // ---------------------------------------------------------------------------
+    // Cleanup
+    // ---------------------------------------------------------------------------
+    /** Remove all permission and config state for a plugin. */
+    clear(pluginId) {
+        this.permissions.delete(pluginId);
+        this.configs.delete(pluginId);
+    }
+}
+exports.PluginSandbox = PluginSandbox;

package/dist/plugins/trust.d.ts

@@ -0,0 +1,31 @@
+export type TrustLevel = 'verified' | 'community' | 'local' | 'unknown';
+export interface PluginProvenance {
+    source: 'npm' | 'git' | 'local' | 'marketplace';
+    author?: string;
+    signature?: string;
+    publishedAt?: string;
+    registryUrl?: string;
+}
+export declare function classifyTrust(provenance: PluginProvenance): TrustLevel;
+interface BlocklistData {
+    blocked: Array<{
+        pluginId: string;
+        reason?: string;
+        blockedAt: string;
+    }>;
+}
+export declare function loadBlocklist(configDir: string): BlocklistData;
+export declare function isBlocked(configDir: string, pluginId: string): boolean;
+export declare function addToBlocklist(configDir: string, pluginId: string, reason?: string): void;
+export declare function removeFromBlocklist(configDir: string, pluginId: string): boolean;
+export type TrustClass = 'system' | 'verified' | 'community' | 'sandboxed';
+export interface PluginTrustPolicy {
+    allowedPermissions: Set<string>;
+}
+export declare const DEFAULT_TRUST_POLICIES: Record<TrustClass, PluginTrustPolicy>;
+export declare function evaluatePluginTrust(requestedPermissions: string[], trustClass: TrustClass, policy?: Record<TrustClass, PluginTrustPolicy>): {
+    allowed: boolean;
+    deniedPermissions: string[];
+};
+export {};
+//# sourceMappingURL=trust.d.ts.map

package/dist/plugins/trust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust.d.ts","sourceRoot":"","sources":["../../src/plugins/trust.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO,GAAG,SAAS,CAAC;AAExE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,aAAa,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,gBAAgB,GAAG,UAAU,CAKtE;AAID,UAAU,aAAa;IACrB,OAAO,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC1E;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAQ9D;AAED,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGtE;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAOzF;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAOhF;AAED,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAE3E,MAAM,WAAW,iBAAiB;IAChC,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACjC;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,UAAU,EAAE,iBAAiB,CAKxE,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,oBAAoB,EAAE,MAAM,EAAE,EAC9B,UAAU,EAAE,UAAU,EACtB,MAAM,wCAAyB,GAC9B;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,MAAM,EAAE,CAAA;CAAE,CAInD"}

package/dist/plugins/trust.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TRUST_POLICIES = void 0;
+exports.classifyTrust = classifyTrust;
+exports.loadBlocklist = loadBlocklist;
+exports.isBlocked = isBlocked;
+exports.addToBlocklist = addToBlocklist;
+exports.removeFromBlocklist = removeFromBlocklist;
+exports.evaluatePluginTrust = evaluatePluginTrust;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function classifyTrust(provenance) {
+    if (provenance.signature && provenance.source === 'marketplace')
+        return 'verified';
+    if (provenance.source === 'npm' && provenance.author)
+        return 'community';
+    if (provenance.source === 'local')
+        return 'local';
+    return 'unknown';
+}
+const BLOCKLIST_FILENAME = 'plugin-blocklist.json';
+function loadBlocklist(configDir) {
+    const filePath = (0, node_path_1.join)(configDir, BLOCKLIST_FILENAME);
+    if (!(0, node_fs_1.existsSync)(filePath))
+        return { blocked: [] };
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(filePath, 'utf8'));
+    }
+    catch {
+        return { blocked: [] };
+    }
+}
+function isBlocked(configDir, pluginId) {
+    const data = loadBlocklist(configDir);
+    return data.blocked.some(b => b.pluginId === pluginId);
+}
+function addToBlocklist(configDir, pluginId, reason) {
+    const data = loadBlocklist(configDir);
+    if (data.blocked.some(b => b.pluginId === pluginId))
+        return;
+    data.blocked.push({ pluginId, reason, blockedAt: new Date().toISOString() });
+    const filePath = (0, node_path_1.join)(configDir, BLOCKLIST_FILENAME);
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.dirname)(filePath)))
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(filePath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+function removeFromBlocklist(configDir, pluginId) {
+    const data = loadBlocklist(configDir);
+    const before = data.blocked.length;
+    data.blocked = data.blocked.filter(b => b.pluginId !== pluginId);
+    if (data.blocked.length === before)
+        return false;
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(configDir, BLOCKLIST_FILENAME), JSON.stringify(data, null, 2), 'utf8');
+    return true;
+}
+exports.DEFAULT_TRUST_POLICIES = {
+    system: { allowedPermissions: new Set(['tools:register', 'commands:register', 'keybindings:register', 'events:listen', 'statusbar:register', 'context:inject', 'filesystem:read', 'filesystem:write', 'network:outbound', 'subprocess:spawn']) },
+    verified: { allowedPermissions: new Set(['tools:register', 'commands:register', 'keybindings:register', 'events:listen', 'statusbar:register', 'context:inject', 'filesystem:read', 'network:outbound']) },
+    community: { allowedPermissions: new Set(['tools:register', 'commands:register', 'events:listen', 'statusbar:register', 'context:inject']) },
+    sandboxed: { allowedPermissions: new Set(['tools:register', 'events:listen']) },
+};
+function evaluatePluginTrust(requestedPermissions, trustClass, policy = exports.DEFAULT_TRUST_POLICIES) {
+    const allowed = policy[trustClass].allowedPermissions;
+    const denied = requestedPermissions.filter(p => !allowed.has(p));
+    return { allowed: denied.length === 0, deniedPermissions: denied };
+}

package/dist/plugins/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Plugin sandboxing types for L6 Agent-Platform.
+ * Defines the permission model, manifest schema, instance lifecycle,
+ * and sandbox configuration for loaded plugins.
+ */
+export type PluginPermission = 'fs:read' | 'fs:write' | 'net:outbound' | 'process:spawn' | 'env:read' | 'mcp:connect' | 'shell:execute';
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    permissions: PluginPermission[];
+    entrypoint: string;
+    minPlatformVersion?: string;
+}
+export type PluginStatus = 'loaded' | 'unloaded' | 'error' | 'loading';
+export interface PluginInstance {
+    manifest: PluginManifest;
+    status: PluginStatus;
+    loadedAt?: number;
+    error?: string;
+}
+export interface PluginSandboxConfig {
+    maxMemoryMb?: number;
+    timeoutMs?: number;
+    allowedPaths?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plugins/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,UAAU,GACV,cAAc,GACd,eAAe,GACf,UAAU,GACV,aAAa,GACb,eAAe,CAAC;AAEpB,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvE,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,cAAc,CAAC;IACzB,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB"}

package/dist/plugins/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Plugin sandboxing types for L6 Agent-Platform.
+ * Defines the permission model, manifest schema, instance lifecycle,
+ * and sandbox configuration for loaded plugins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugins/validation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plugin validation — structural checks for manifests and installed plugin
+ * directories.
+ *
+ * `validatePlugin` performs in-memory manifest validation.
+ * `diagnosePlugin` inspects the file-system layout of a plugin directory.
+ * `formatDiagnostics` renders issues into a human-readable report.
+ */
+import type { PluginManifest } from './types';
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface DiagnosticEntry {
+    level: 'error' | 'warning' | 'info';
+    message: string;
+}
+/**
+ * Validate a plugin manifest in memory.
+ * Returns errors (fatal) and warnings (non-fatal observations).
+ */
+export declare function validatePlugin(manifest: PluginManifest): ValidationResult;
+/**
+ * Inspect a plugin directory on disk and return diagnostic entries.
+ */
+export declare function diagnosePlugin(pluginDir: string): DiagnosticEntry[];
+/**
+ * Render diagnostic entries into a human-readable multi-line string.
+ */
+export declare function formatDiagnostics(entries: DiagnosticEntry[]): string;
+//# sourceMappingURL=validation.d.ts.map

package/dist/plugins/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/plugins/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,SAAS,CAAC;AAMhE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAgBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,GAAG,gBAAgB,CAsCzE;AAMD;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CA6BnE;AAYD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAKpE"}