elanous 0.2.21 → 0.2.23

package/src/plugins/core/host.ts

@@ -38,7 +38,7 @@ import { debug } from '../../debug/log.js';
 import { getSessionCwd } from '../../session/working-dir.js';
 import { CommandRegistry, type CommandDisposable, type RegisteredCommand } from '../../command-registry.js';
 import { PluginCapabilityPolicy, assertCapability } from './capability-policy.js';
-import { PluginTrustStore } from './trust-store.js';
+import { PluginTrustStore, enabledPluginHooks } from './trust-store.js';
 import { PluginTaskService } from './task-service.js';
 import { readClipboardText, writeClipboard } from '../../clipboard/index.js';
 import {
@@ -54,6 +54,7 @@ import { getGlobalElementRegistry, publishElementEvent } from '../../element-reg
 import { mintPluginUri } from '../../mss/uri/builder.js';
 import type { PluginUri } from '../../mss/uri/brand.js';
 import { loadPluginNodes } from '../../graph-kinds/plugin-nodes.js';
+import { registerOutboundAdapter } from '../../nexus/outbound/router.js';
 import { getNodeKindRegistration, listNodeKinds, unregisterPluginNodeKind, type NodeKindEntry } from '../../graph-kinds/registry.js';
 
 /** Clamp a tool handler's return value to something short enough for
@@ -113,8 +114,10 @@ export interface ActivePlugin {
   ownedCommandDisposables: CommandDisposable[];
   /** Task registrations for this activation. */
   ownedTaskDisposables: Array<{ dispose(): void }>;
-  /** PX-3: hook registrations (from manifest.contributes.hooks[] +
-   *  ctx.hooks.register calls). Disposed on deactivate. */
+  /** Connector registrations are owner-scoped and removed on deactivate. */
+  ownedChannelDisposers: Array<() => void>;
+  /** Hook registrations from manifest.contributes.hooks[]; disposed on deactivate.
+   *  PluginContext does not expose a programmatic hooks registration API. */
   ownedHookDisposers: Array<() => void>;
   /** PX-4: mission registrations (one per contributes.missions[] entry).
    *  Disposers tear down globalMissionRegistry entries on deactivate. */
@@ -369,13 +372,12 @@ export class PluginHost {
     }
   }
 
-  /** PX-3 P4: register all manifest-declared shell hooks for the
-   *  plugin we're activating. Disposers are tracked on the active
-   *  entry so deactivate() unregisters them. In-process hooks go
-   *  through ctx.hooks.register inside onActivate (see buildContext). */
+  /** Register manifest-declared shell hooks for the plugin being activated.
+   *  Installed plugins' hooks stay off (no approval path); disposers unregister them on deactivate. */
   private registerManifestHooks(entry: PluginEntry): void {
     if (!this.activeEntry) return;
-    const specs = entry.manifest.contributes.hooks ?? [];
+    const declared = entry.manifest.contributes.hooks ?? [];
+    const specs = enabledPluginHooks(declared, entry.source);
     if (specs.length === 0) return;
     // Lazy imports so headless tests that don't exercise hooks never
     // pull in the dispatcher stack.
@@ -770,6 +772,7 @@ export class PluginHost {
       ownedDisplayDisposables: [],
       ownedCommandDisposables: [],
       ownedTaskDisposables: [],
+      ownedChannelDisposers: [],
       ownedHookDisposers: [],
       ownedMissionDisposers: [],
       ownedRouteDisposers: [],
@@ -822,6 +825,13 @@ export class PluginHost {
     const ctx = this.buildContext();
     try {
       await plugin.onActivate?.(ctx);
+      for (const adapter of plugin.channelAdapters ?? []) {
+        if (!entry.manifest.contributes.connectors?.some(connector => connector.id === adapter.type)) {
+          throw new Error(`channel connector ${adapter.type} must be declared in contributes.connectors`);
+        }
+        // The manifest declaration alone is not an active channel.
+        this.activeEntry.ownedChannelDisposers.push(registerOutboundAdapter(adapter));
+      }
       // Resolve layout after onActivate so the plugin can initialize
       // state first (e.g. fetch remote rows). buildLayout can spawn
       // widgets via the tracked helper — we record ids for dispose.
@@ -848,6 +858,7 @@ export class PluginHost {
         for (const d of this.activeEntry.ownedDisplayDisposables) d.dispose();
         for (const d of this.activeEntry.ownedCommandDisposables) d.dispose();
         for (const d of this.activeEntry.ownedTaskDisposables) d.dispose();
+        for (const d of this.activeEntry.ownedChannelDisposers) d();
         for (const d of this.activeEntry.ownedHookDisposers) d();
         for (const d of this.activeEntry.ownedMissionDisposers) d();
         for (const d of this.activeEntry.ownedRouteDisposers) d();
@@ -880,6 +891,7 @@ export class PluginHost {
     for (const d of this.activeEntry.ownedDisplayDisposables) d.dispose();
     for (const d of this.activeEntry.ownedCommandDisposables) d.dispose();
     for (const d of this.activeEntry.ownedTaskDisposables) d.dispose();
+    for (const d of this.activeEntry.ownedChannelDisposers) d();
     const promptStore = getPromptBankStore();
     for (const id of this.activeEntry.promptFragmentIds) promptStore.delete(id);
     // PX-3: dispose hook registrations for this plugin.
@@ -1746,6 +1758,7 @@ function normalizePluginExport(plugin: Partial<ElanousPlugin>, manifest: PluginM
     ...(plugin.slashCommands ? { slashCommands: plugin.slashCommands } : {}),
     ...(plugin.keybindings ? { keybindings: plugin.keybindings } : {}),
     ...(plugin.llmTools ? { llmTools: plugin.llmTools } : {}),
+    ...(plugin.channelAdapters ? { channelAdapters: plugin.channelAdapters } : {}),
     ...(plugin.onActivate ? { onActivate: plugin.onActivate } : {}),
     ...(plugin.onDeactivate ? { onDeactivate: plugin.onDeactivate } : {}),
     ...(plugin.isBusy ? { isBusy: plugin.isBusy } : {}),

package/src/plugins/core/manifest.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import type { Keybinding, SlashCommand } from './types.js';
+import type { Keybinding, PluginDependency, SlashCommand } from './types.js';
 import type { PromptKind, PromptScope, PromptTargetSlot } from '../../prompt-bank/types.js';
 import type {
   MissionDefinition,
@@ -223,6 +223,8 @@ export interface PluginManifest {
   activationEvents: string[];
   contributes: PluginManifestContributes;
   capabilities: PluginCapability[];
+  /** `plugin.json` requirement metadata; does not trigger installation. */
+  requires?: PluginDependency;
   dependencies?: {
     widgets?: string[];
     plugins?: string[];
@@ -328,6 +330,7 @@ export function parsePluginManifest(
       ? raw.capabilities
       : [...parseCapabilities(raw.capabilities), ...parseCapabilities(extension.capabilities)]);
   const dependencies = parseDependencies(raw.dependencies);
+  const requires = parsePluginRequires(raw.requires === undefined ? extension.requires : raw.requires);
   const description = typeof raw.description === 'string' ? raw.description : undefined;
   const allowMultiActive = typeof raw.allowMultiActive === 'boolean' ? raw.allowMultiActive : undefined;
   const activePeerCompat = parseActivePeerCompat(raw.activePeerCompat);
@@ -341,6 +344,7 @@ export function parsePluginManifest(
     activationEvents,
     contributes,
     capabilities,
+    ...(requires ? { requires } : {}),
     ...(dependencies ? { dependencies } : {}),
     ...(allowMultiActive !== undefined ? { allowMultiActive } : {}),
     ...(activePeerCompat ? { activePeerCompat } : {}),
@@ -354,7 +358,7 @@ function objectOrEmpty(value: unknown, label: string): Record<string, unknown> {
   return value as Record<string, unknown>;
 }
 
-function parseElanousExtension(value: unknown): { contributes: Record<string, unknown>; capabilities?: unknown } {
+function parseElanousExtension(value: unknown): { contributes: Record<string, unknown>; capabilities?: unknown; requires?: unknown } {
   const extensions = objectOrEmpty(value, 'extensions');
   const extension = objectOrEmpty(extensions['ai.elanous'], 'extensions["ai.elanous"]');
   const contributes = objectOrEmpty(extension.contributes, 'extensions["ai.elanous"].contributes');
@@ -365,6 +369,7 @@ function parseElanousExtension(value: unknown): { contributes: Record<string, un
         .map(key => [key, extension[key]])),
     },
     capabilities: extension.capabilities,
+    requires: extension.requires,
   };
 }
 
@@ -1117,6 +1122,18 @@ function parseCapabilities(value: unknown): PluginCapability[] {
   });
 }
 
+function parsePluginRequires(value: unknown): PluginDependency | undefined {
+  if (value === undefined) return undefined;
+  const raw = objectOrEmpty(value, 'requires');
+  return {
+    ...(raw.elanous !== undefined ? { elanous: stringOr(raw.elanous) } : {}),
+    ...(raw.tools !== undefined ? { tools: stringArrayOr(raw.tools, []) } : {}),
+    ...(raw.optionalTools !== undefined ? { optionalTools: stringArrayOr(raw.optionalTools, []) } : {}),
+    ...(raw.optionalPython !== undefined ? { optionalPython: stringArrayOr(raw.optionalPython, []) } : {}),
+    ...(raw.knowledgePacks !== undefined ? { knowledgePacks: stringArrayOr(raw.knowledgePacks, []) } : {}),
+  };
+}
+
 function parseDependencies(value: unknown): PluginManifest['dependencies'] | undefined {
   if (value === undefined) return undefined;
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('dependencies must be an object');

package/src/plugins/core/trust-store.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { DATA_DIR } from '../../config.js';
+import type { PluginSecurityDecision } from './capability-policy.js';
 
 export type PluginTrustScope = 'user' | 'workspace';
 
@@ -16,6 +17,20 @@ interface PluginTrustFile {
   records: PluginTrustRecord[];
 }
 
+/** Ephemeral installation decision; never persisted as a trust record or a credential. */
+export function decidePluginInstallation(security: PluginSecurityDecision, capabilities: readonly string[], consent: boolean):
+  { ok: true } | { ok: false; reason: 'scan' | 'consent-denied' } {
+  if (security.scan === 'dangerous') return { ok: false, reason: 'scan' };
+  if (capabilities.length > 0 && !consent) return { ok: false, reason: 'consent-denied' };
+  return { ok: true };
+}
+
+/** Hooks default off for installed (imported/generated) plugins: there is no approval path yet, so none run.
+ *  Built-in and user-dir plugins keep their declared hooks unchanged. */
+export function enabledPluginHooks<T>(hooks: readonly T[], source: string): T[] {
+  return source === 'installed' ? [] : [...hooks];
+}
+
 export class PluginTrustStore {
   constructor(private readonly path = defaultPluginTrustPath()) {}
 

package/src/plugins/core/types.ts

@@ -26,6 +26,15 @@ import type {
 
 export type PaneSlot = 'skills' | 'files' | 'preview' | 'log' | 'hud';
 
+/** Requirements declared by a plugin.json `requires` block. This is metadata, not an install request. */
+export interface PluginDependency {
+  elanous?: string;
+  tools?: string[];
+  optionalTools?: string[];
+  optionalPython?: string[];
+  knowledgePacks?: string[];
+}
+
 export interface DashboardPaneSummary {
   pane: string;
   visible: boolean;
@@ -327,6 +336,9 @@ export interface ElanousPlugin<S = unknown> {
   slashCommands?: SlashCommand[];
   keybindings?: Keybinding[];
   llmTools?: LLMToolDef[];
+  /** Host registers only adapters also declared in contributes.connectors;
+   * registration is disposed with this plugin activation. */
+  channelAdapters?: import('../../nexus/outbound/router.js').ChannelAdapter[];
   onActivate?(ctx: PluginContext): void | Promise<void>;
   onDeactivate?(ctx: PluginContext): void | Promise<void>;
   /** Plugin is executing a long-running op — host blocks input while true.

package/src/plugins/install/market-fetch.ts

@@ -13,7 +13,14 @@ export const ELANOUS_MARKET_URL = 'https://elanvitalai.github.io/elanous-plugins
 const NAME = /^[a-z0-9][a-z0-9-]{1,39}$/;
 const MAX_INDEX_BYTES = 8 * 1024 * 1024;
 
-export interface MarketConfig { name: string; url: string }
+export interface MarketConfig {
+  name: string;
+  url: string;
+  /** Explicit tenant allowlist for a private market; absent for existing plugin markets. */
+  enterpriseIds?: string[];
+  /** Keys bound to this private market, never inherited from the global plugin trust pool. */
+  trustedKeys?: Array<{ keyId: string; publicKey: string }>;
+}
 export interface MarketFetchOptions {
   root?: string;
   marketDir?: string;
@@ -75,6 +82,24 @@ function configuredMarkets(settings: Record<string, unknown>): MarketConfig[] {
     return { name, url: marketUrl(url) };
   });
 }
+function internalMarkets(settings: Record<string, unknown>): MarketConfig[] {
+  const entries = settings.internalMarkets;
+  if (entries === undefined) return [];
+  if (!Array.isArray(entries)) throw new MarketFetchError('io', 'invalid internal markets configuration');
+  const names = new Set<string>();
+  return entries.map((entry: unknown) => {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) throw new MarketFetchError('io', 'invalid internal market configuration');
+    const { name, url, enterpriseIds, trustedKeys } = entry as Record<string, unknown>;
+    if (typeof name !== 'string' || !NAME.test(name) || names.has(name) || name === 'elanous') throw new MarketFetchError('io', `invalid or duplicate internal market name: ${String(name)}`);
+    if (!Array.isArray(enterpriseIds) || !enterpriseIds.length || !enterpriseIds.every(id => typeof id === 'string' && id.trim() && id === id.trim())
+      || new Set(enterpriseIds).size !== enterpriseIds.length) throw new MarketFetchError('io', `invalid internal market enterprise allowlist: ${name}`);
+    if (!Array.isArray(trustedKeys) || !trustedKeys.length || !trustedKeys.every(key => key && typeof key === 'object' && typeof key.keyId === 'string' && /^[a-fA-F0-9]{8}$/.test(key.keyId) && typeof key.publicKey === 'string' && key.publicKey.length > 0)
+      || new Set(trustedKeys.map(key => key.keyId)).size !== trustedKeys.length) throw new MarketFetchError('io', `invalid internal market trusted keys: ${name}`);
+    names.add(name);
+    return { name, url: marketUrl(url), enterpriseIds: enterpriseIds as string[], trustedKeys: trustedKeys as Array<{ keyId: string; publicKey: string }> };
+  });
+}
+
 function trust(settings: Record<string, unknown>, opts: MarketFetchOptions): ReadonlyArray<{ keyId: string; publicKey: string }> {
   const additional = settings.trustedKeys;
   if (additional !== undefined && (!Array.isArray(additional) || !additional.every(key => key && typeof key.keyId === 'string' && typeof key.publicKey === 'string'))) {
@@ -115,7 +140,7 @@ function location(name: string, opts: MarketFetchOptions): string {
   return join(resolve(opts.marketDir ?? join(opts.root ?? elanousStateRoot(), 'markets')), name);
 }
 
-interface CacheState { url: string; lastSequence: number; indexHash: string; signatureHash: string }
+interface CacheState { url: string; lastSequence: number; indexHash: string; signatureHash: string; trustHash?: string }
 
 function cacheState(path: string): CacheState | undefined {
   if (!existsSync(path)) return undefined;
@@ -123,13 +148,14 @@ function cacheState(path: string): CacheState | undefined {
   try { value = JSON.parse(readFileSync(path, 'utf8')); }
   catch { throw new MarketFetchError('io', 'invalid market cache state'); }
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new MarketFetchError('io', 'invalid market cache state');
-  const { url, lastSequence, indexHash, signatureHash } = value as Record<string, unknown>;
+  const { url, lastSequence, indexHash, signatureHash, trustHash } = value as Record<string, unknown>;
   if (typeof url !== 'string' || !Number.isSafeInteger(lastSequence) || (lastSequence as number) < 0
     || typeof indexHash !== 'string' || !/^[a-f0-9]{64}$/.test(indexHash)
-    || typeof signatureHash !== 'string' || !/^[a-f0-9]{64}$/.test(signatureHash)) {
+    || typeof signatureHash !== 'string' || !/^[a-f0-9]{64}$/.test(signatureHash)
+    || (trustHash !== undefined && (typeof trustHash !== 'string' || !/^[a-f0-9]{64}$/.test(trustHash)))) {
     throw new MarketFetchError('io', 'invalid market cache state');
   }
-  return { url, lastSequence: lastSequence as number, indexHash, signatureHash };
+  return { url, lastSequence: lastSequence as number, indexHash, signatureHash, ...(trustHash === undefined ? {} : { trustHash }) };
 }
 
 function digest(bytes: Uint8Array | string): string {
@@ -147,9 +173,21 @@ function checked(bytes: Uint8Array, signatureText: string, name: string, keys: R
 const marketIndexQueues = new Map<string, Promise<void>>();
 
 export function ensureMarketIndex(name: string, opts: MarketFetchOptions = {}): Promise<MarketIndex> {
-  const directory = location(name, opts);
+  return queuedMarketIndex(name, opts);
+}
+
+/** Private indices require a configured market, a bound signing key and an explicitly allowed enterprise. */
+export function ensureInternalMarketIndex(name: string, enterpriseId: string, opts: MarketFetchOptions = {}): Promise<MarketIndex> {
+  if (typeof enterpriseId !== 'string' || !enterpriseId.trim() || enterpriseId !== enterpriseId.trim()) {
+    return Promise.reject(new MarketFetchError('io', `enterprise not allowed for internal market: ${name}`));
+  }
+  return queuedMarketIndex(name, opts, enterpriseId);
+}
+
+function queuedMarketIndex(name: string, opts: MarketFetchOptions, enterpriseId?: string): Promise<MarketIndex> {
+  const directory = enterpriseId === undefined ? location(name, opts) : join(resolve(opts.marketDir ?? join(opts.root ?? elanousStateRoot(), 'markets')), '.internal', name, digest(enterpriseId));
   const previous = marketIndexQueues.get(directory) ?? Promise.resolve();
-  const result = previous.then(() => fetchMarketIndex(name, opts));
+  const result = previous.then(() => fetchMarketIndex(name, opts, enterpriseId, directory));
   const tail = result.then(() => {}, () => {});
   marketIndexQueues.set(directory, tail);
   void tail.then(() => {
@@ -158,11 +196,25 @@ export function ensureMarketIndex(name: string, opts: MarketFetchOptions = {}):
   return result;
 }
 
-async function fetchMarketIndex(name: string, opts: MarketFetchOptions): Promise<MarketIndex> {
-  const market = listMarkets(opts).find(entry => entry.name === name);
+async function fetchMarketIndex(name: string, opts: MarketFetchOptions, enterpriseId: string | undefined, directory: string): Promise<MarketIndex> {
+  const settings = marketSettings(config(opts));
+  const market: MarketConfig | undefined = enterpriseId === undefined
+    ? [{ name: 'elanous', url: ELANOUS_MARKET_URL }, ...configuredMarkets(settings)].find(entry => entry.name === name)
+    : internalMarkets(settings).find(entry => entry.name === name);
   if (!market) throw new MarketFetchError('io', `market not configured: ${name}`);
-  const keys = trust(marketSettings(config(opts)), opts);
-  const directory = location(name, opts);
+  if (enterpriseId !== undefined && !market.enterpriseIds?.includes(enterpriseId)) {
+    throw new MarketFetchError('io', `enterprise not allowed for internal market: ${name}`);
+  }
+  const keys = enterpriseId === undefined ? trust(settings, opts) : market.trustedKeys!;
+  const verificationOptions = enterpriseId === undefined ? opts : { ...opts, verifySignature: verifyIndex };
+  const trustHash = enterpriseId === undefined ? undefined : digest(JSON.stringify(keys));
+  const authorized = (verified: ReturnType<typeof checked>): ReturnType<typeof checked> => {
+    if (enterpriseId !== undefined && [...(verified.index.knowledgePacks ?? []), ...(verified.index.loopBundles ?? [])]
+      .some(entry => entry.visibility !== 'internal' || entry.enterpriseId !== enterpriseId)) {
+      throw new MarketFetchError('io', `internal market contains entries outside enterprise allowlist: ${name}`);
+    }
+    return verified;
+  };
   const indexFile = join(directory, 'marketplace.json');
   const sigFile = join(directory, 'index.sig');
   const stateFile = join(directory, 'cache-state.json');
@@ -170,12 +222,12 @@ async function fetchMarketIndex(name: string, opts: MarketFetchOptions): Promise
   // The URL is part of the cache identity, not just the market name.
   const lastSequence = state?.url === market.url ? state.lastSequence : undefined;
   let cached: ReturnType<typeof checked> | undefined;
-  if (state?.url === market.url && existsSync(indexFile) && existsSync(sigFile)) {
+  if (state?.url === market.url && (trustHash === undefined || state.trustHash === trustHash) && existsSync(indexFile) && existsSync(sigFile)) {
     const indexBytes = readFileSync(indexFile);
     const signatureText = readFileSync(sigFile, 'utf8');
     if (digest(indexBytes) === state.indexHash && digest(signatureText) === state.signatureHash) {
       try {
-        cached = checked(indexBytes, signatureText, name, keys, opts, lastSequence);
+        cached = authorized(checked(indexBytes, signatureText, name, keys, verificationOptions, lastSequence));
       } catch (error) {
         if (!(error instanceof MarketFetchError)) throw error;
       }
@@ -216,13 +268,13 @@ async function fetchMarketIndex(name: string, opts: MarketFetchOptions): Promise
   };
   const bytes = await load('marketplace.json');
   const signature = new TextDecoder('utf-8', { fatal: true }).decode(await load('index.sig'));
-  const verified = checked(bytes, signature, name, keys, opts, lastSequence);
+  const verified = authorized(checked(bytes, signature, name, keys, verificationOptions, lastSequence));
   mkdirSync(directory, { recursive: true });
   // Cross-process: another CLI may have published a newer index since we read cache-state. Re-check the high-water
   // mark under a file lock right before publishing, so a slower process cannot roll the cache back (review R3).
   return withFileLockSync(join(directory, '.publish.lock'), () => {
   const current = cacheState(stateFile);
-  if (current?.url === market.url && current.lastSequence !== undefined && current.lastSequence > verified.index.sequence) {
+  if (current?.url === market.url && current.lastSequence > verified.index.sequence) {
     throw new MarketFetchError('signature', `market index rollback refused: ${name} sequence ${verified.index.sequence} < ${current.lastSequence}`);
   }
   const staging = mkdtempSync(join(directory, '.index-'));
@@ -232,7 +284,7 @@ async function fetchMarketIndex(name: string, opts: MarketFetchOptions): Promise
     const tempState = join(staging, 'cache-state.json');
     writeFileSync(tempIndex, bytes);
     writeFileSync(tempSig, signature);
-    writeFileSync(tempState, JSON.stringify({ url: market.url, lastSequence: verified.index.sequence, indexHash: digest(bytes), signatureHash: digest(signature) } satisfies CacheState));
+    writeFileSync(tempState, JSON.stringify({ url: market.url, lastSequence: verified.index.sequence, indexHash: digest(bytes), signatureHash: digest(signature), ...(trustHash === undefined ? {} : { trustHash }) } satisfies CacheState));
     // Commit the verified high-water mark before replacing either cache file.
     // An interrupted publication then cannot roll back a previously verified index.
     renameSync(tempState, stateFile);