@geraldmaron/construct 1.0.0 → 1.0.1

package/lib/mcp-manager.mjs

@@ -1,14 +1,14 @@
 /**
- * MCP manager — add, remove, list MCPs in ~/.claude/settings.json
- * Uses mcp-catalog.json as the source of truth for known integrations.
+ * MCP manager — add, remove, list MCPs in host configs.
+ * Uses the plugin registry as the source of truth for built-in and external integrations.
  */
 
 import { execSync } from 'node:child_process';
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { homedir, platform } from 'node:os';
 import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { selectOption } from './tty-prompts.mjs';
 import { readOpenCodeConfig, writeOpenCodeConfig } from './opencode-config.mjs';
 import { getUserEnvPath, loadConstructEnv, writeEnvValues } from './env-config.mjs';
 import {
@@ -26,29 +26,18 @@ import {
   buildClaudeMcpEntry,
   buildOpenCodeMcpEntry,
   getOpenCodeMcpId,
-  normalizeInstalledOpenCodeMcpId,
 } from './mcp-platform-config.mjs';
+import { getMcpById as getMcpByIdFromRegistry, loadPluginRegistry } from './plugin-registry.mjs';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const CATALOG_PATH = join(__dirname, 'mcp-catalog.json');
-const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+function getClaudeSettingsPath() {
+  return join(homedir(), '.claude', 'settings.json');
+}
 
 function openUrl(url) {
   try {
     const opener = platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open';
     execSync(`${opener} "${url}"`, { stdio: 'ignore' });
-  } catch {
-    // best effort
-  }
-}
-
-function loadCatalog() {
-  const catalog = JSON.parse(readFileSync(CATALOG_PATH, 'utf8'));
-  return {
-    ...catalog,
-    mcps: (catalog.mcps ?? []).map(normalizeMcp),
-  };
+  } catch { /* browser launch is non-critical */ }
 }
 
 function normalizeMcp(mcp) {
@@ -59,6 +48,7 @@ function normalizeMcp(mcp) {
     requiredEnv: Array.isArray(mcp.requiredEnv) ? mcp.requiredEnv : [],
     setupModes: Array.isArray(mcp.setupModes) ? mcp.setupModes : ['manual'],
     usedBy: Array.isArray(mcp.usedBy) ? mcp.usedBy : [],
+    hostSupport: mcp.hostSupport && typeof mcp.hostSupport === 'object' ? mcp.hostSupport : {},
   };
 }
 
@@ -66,6 +56,24 @@ function hasSetupMode(mcp, mode) {
   return mcp.setupModes.includes(mode);
 }
 
+function getHostSupport(mcp, host) {
+  const support = mcp?.hostSupport?.[host];
+  if (!support) return { mode: 'managed' };
+  if (typeof support === 'string') return { mode: support };
+  if (typeof support === 'object') return { mode: support.mode ?? 'managed', ...support };
+  return { mode: 'managed' };
+}
+
+function isManagedOnHost(mcp, host) {
+  return getHostSupport(mcp, host).mode === 'managed';
+}
+
+function collectPluginBackedMcpIds(catalog) {
+  return (catalog.mcps ?? [])
+    .filter((mcp) => ['claude', 'opencode', 'codex'].some((host) => getHostSupport(mcp, host).mode === 'plugin'))
+    .map((mcp) => mcp.id);
+}
+
 function parseAddFlags() {
   const args = new Set(process.argv.slice(2));
   return {
@@ -86,13 +94,22 @@ async function chooseSetupMode(mcp, flags) {
   if (!canManual) return 'auto';
   if (!process.stdin.isTTY) return 'manual';
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  console.log('\nSetup mode:');
-  console.log('  1) Auto-configure what Construct can detect or provision');
-  console.log('  2) Manual setup (I will provide credentials/URLs myself)');
-  const answer = await prompt(rl, '  Choice [1/2]: ');
-  rl.close();
-  return answer.trim() === '2' ? 'manual' : 'auto';
+  return selectOption({
+    title: 'Choose setup mode',
+    instructions: 'Pick how Construct should configure this integration.',
+    options: [
+      {
+        value: 'auto',
+        label: 'Auto-configure',
+        description: 'Let Construct detect, provision, or prefill what it can.',
+      },
+      {
+        value: 'manual',
+        label: 'Manual setup',
+        description: 'Provide credentials, URLs, and config values yourself.',
+      },
+    ],
+  });
 }
 
 function getConfiguredEnvValue(name) {
@@ -130,17 +147,19 @@ function getConfiguredEnvValues(mcp) {
 }
 
 function loadSettings() {
-  if (!existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  const claudeSettingsPath = getClaudeSettingsPath();
+  if (!existsSync(claudeSettingsPath)) return {};
   try {
-    return JSON.parse(readFileSync(CLAUDE_SETTINGS_PATH, 'utf8'));
+    return JSON.parse(readFileSync(claudeSettingsPath, 'utf8'));
   } catch {
     return {};
   }
 }
 
 function saveSettings(settings) {
-  mkdirSync(dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
-  writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n');
+  const claudeSettingsPath = getClaudeSettingsPath();
+  mkdirSync(dirname(claudeSettingsPath), { recursive: true });
+  writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2) + '\n');
 }
 
 function loadOpenCodeConfig() {
@@ -152,20 +171,23 @@ function saveOpenCodeConfig(config) {
 }
 
 function getMcpById(id) {
-  const catalog = loadCatalog();
-  return catalog.mcps.find(m => m.id === id) ?? null;
+  return getMcpByIdFromRegistry(id, { cwd: process.cwd(), homeDir: homedir() });
 }
 
 function getInstalledMcps() {
+  const registry = loadPluginRegistry({ cwd: process.cwd(), homeDir: homedir() });
   const settings = loadSettings();
   const oc = loadOpenCodeConfig();
   const codexConfig = readCodexConfig();
   const codexServers = Array.from(codexConfig.matchAll(/^\[mcp_servers\.("?)([^"\]\n]+)\1\]/gm)).map((match) => match[2]);
   const set = new Set([
     ...Object.keys(settings.mcpServers ?? {}),
-    ...Object.keys(oc.mcp ?? {}).map(normalizeInstalledOpenCodeMcpId),
+    ...Object.keys(oc.mcp ?? {}),
     ...codexServers,
   ]);
+  for (const id of collectPluginBackedMcpIds({ mcps: registry.mcps.map(normalizeMcp) })) {
+    set.add(id);
+  }
   return Array.from(set);
 }
 
@@ -196,14 +218,20 @@ function removeCodexMcp(id) {
  * Show all MCPs from catalog with installed/missing status.
  */
 export function cmdMcpList() {
-  const catalog = loadCatalog();
+  const registry = loadPluginRegistry({ cwd: process.cwd(), homeDir: homedir() });
   const installed = new Set(getInstalledMcps());
 
+  if (!registry.valid) {
+    console.log('Plugin registry errors:');
+    for (const error of registry.errors) console.log(`  ✗ ${error}`);
+    console.log('');
+  }
+
   const categories = ['core', 'optional', 'integration'];
   const labels = { core: 'Core (Essential)', optional: 'Enhancements', integration: 'Third-Party' };
 
   for (const cat of categories) {
-    const mcps = catalog.mcps.filter(m => m.category === cat);
+    const mcps = registry.mcps.filter(m => m.category === cat);
     if (!mcps.length) continue;
 
     console.log(`\n${labels[cat]}:`);
@@ -212,7 +240,8 @@ export function cmdMcpList() {
       const status = installed.has(mcp.id) ? '✓' : '·';
       const name = mcp.name.padEnd(20);
       const req = mcp.requiredEnv.length ? ` [needs: ${mcp.requiredEnv.join(', ')}]` : '';
-      console.log(`  ${status} ${name} ${mcp.description.substring(0, 50)}${req}`);
+      const source = mcp.pluginId !== 'construct-builtins' ? ` [plugin: ${mcp.pluginId}]` : '';
+      console.log(`  ${status} ${name} ${mcp.description.substring(0, 50)}${req}${source}`);
     }
   }
 
@@ -338,7 +367,11 @@ export async function cmdMcpAdd(id) {
   // Write to Claude settings
   const settings = loadSettings();
   if (!settings.mcpServers) settings.mcpServers = {};
-  settings.mcpServers[id] = buildClaudeMcpEntry(id, mcp, resolvedValues);
+  if (isManagedOnHost(mcp, 'claude')) {
+    settings.mcpServers[id] = buildClaudeMcpEntry(id, mcp, resolvedValues);
+  } else {
+    delete settings.mcpServers[id];
+  }
   saveSettings(settings);
 
   // Write to OpenCode config
@@ -346,13 +379,19 @@ export async function cmdMcpAdd(id) {
   if (!oc.mcp) oc.mcp = {};
   const openCodeId = getOpenCodeMcpId(id);
   delete oc.mcp[id];
-  oc.mcp[openCodeId] = buildOpenCodeMcpEntry(id, mcp, resolvedValues).entry;
+  if (id === 'memory') delete oc.mcp.cass;
+  if (isManagedOnHost(mcp, 'opencode')) {
+    oc.mcp[openCodeId] = buildOpenCodeMcpEntry(id, mcp, resolvedValues).entry;
+  } else {
+    delete oc.mcp[openCodeId];
+  }
   saveOpenCodeConfig(oc);
 
-  // Write to Codex config. GitHub uses the official remote server URL so Codex
-  // can authenticate via `codex mcp login github` instead of launching stale
-  // local github-mcp-server binaries.
-  writeCodexMcp(id, mcp, resolvedValues);
+  if (isManagedOnHost(mcp, 'codex')) {
+    writeCodexMcp(id, mcp, resolvedValues);
+  } else {
+    removeCodexMcp(id);
+  }
 
   // --- SYNC TO .ENV ---
   const envPath = getUserEnvPath(homedir());
@@ -364,8 +403,14 @@ export async function cmdMcpAdd(id) {
   console.log(`✓ Setup mode: ${setupMode}`);
   console.log(`✓ Services synchronized.`);
   console.log(`\nNext: Restart OpenCode, Claude Code, or Codex to activate the new tools.`);
-  if (id === 'github') {
-    console.log('      For Codex OAuth, run: codex mcp login github');
+  for (const host of ['claude', 'opencode', 'codex']) {
+    const support = getHostSupport(mcp, host);
+    const hostLabel = host === 'claude' ? 'Claude Code' : host === 'opencode' ? 'OpenCode' : 'Codex';
+    if (support.mode === 'plugin') {
+      console.log(`      ${hostLabel} uses ${support.label ?? 'a native plugin/app path'} for ${mcp.name}; Construct does not install a standalone MCP there.`);
+    } else if (support.mode === 'unsupported') {
+      console.log(`      ${hostLabel} does not support managed ${mcp.name} setup.`);
+    }
   }
   
   if (mcp.usedBy.length) {
@@ -382,11 +427,11 @@ export function cmdMcpRemove(id) {
   const oc = openCodeState.config ?? {};
   const openCodeId = getOpenCodeMcpId(id);
   const hasClaudeEntry = Boolean(settings.mcpServers?.[id]);
-  const hasOpenCodeEntry = Boolean(oc.mcp?.[openCodeId] || oc.mcp?.[id]);
+  const hasOpenCodeEntry = Boolean(oc.mcp?.[openCodeId] || oc.mcp?.[id] || (id === 'memory' && oc.mcp?.cass));
   const hasCodexEntry = readCodexConfig().includes(`[mcp_servers.${id}]`) || readCodexConfig().includes(`[mcp_servers.${tomlString(id)}]`);
   if (!hasClaudeEntry && !hasOpenCodeEntry && !hasCodexEntry) {
-    console.error(`${id} is not installed.`);
-    process.exit(1);
+    console.log(`${id} is not installed. Nothing to remove.`);
+    return;
   }
 
   const mcp = getMcpById(id);
@@ -398,8 +443,10 @@ export function cmdMcpRemove(id) {
   if (oc.mcp) {
     delete oc.mcp[openCodeId];
     delete oc.mcp[id];
+    if (id === 'memory') delete oc.mcp.cass;
   }
   if (openCodeState.config || hasOpenCodeEntry) saveOpenCodeConfig(oc);
+  else if (openCodeState.file && existsSync(openCodeState.file)) rmSync(openCodeState.file, { force: true });
   removeCodexMcp(id);
 
   console.log(`✓ ${name} removed from Claude Code, OpenCode, and Codex config`);
@@ -422,6 +469,7 @@ export function cmdMcpInfo(id) {
   console.log('─'.repeat(48));
   console.log(`Status:   ${installed ? '✓ installed' : '· not installed'}`);
   console.log(`Category: ${mcp.category}`);
+  console.log(`Plugin:   ${mcp.pluginName} (${mcp.pluginId})`);
   if (mcp.package) console.log(`Package:  ${mcp.package}`);
   console.log(`\n${mcp.description}`);
   if (mcp.setupUrl) console.log(`\nSetup:    ${mcp.setupUrl}`);

package/lib/mcp-platform-config.mjs

@@ -1,14 +1,17 @@
 /**
- * lib/mcp-platform-config.mjs — <one-line purpose>
+ * lib/mcp-platform-config.mjs — Resolve MCP server config paths for Claude and OpenCode.
  *
- * <2–6 line summary: what it does, who calls it, key side effects.>
+ * Provides platform-aware path resolution for ~/.claude/claude_desktop_config.json
+ * and the OpenCode settings file, abstracting OS and install-location differences.
+ * Backs mcp-manager and setup when they read and write MCP server registrations.
  */
-export function getOpenCodeMcpId(id) {
-  return id === "memory" ? "cass" : id;
-}
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
-export function normalizeInstalledOpenCodeMcpId(id) {
-  return id === "cass" ? "memory" : id;
+const ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+export function getOpenCodeMcpId(id) {
+  return id;
 }
 
 function resolveTemplateString(value, resolvedValues) {
@@ -68,36 +71,33 @@ export function buildClaudeMcpEntry(id, mcpDef, resolvedValues = {}) {
 }
 
 export function buildOpenCodeMcpEntry(id, mcpDef, resolvedValues = {}) {
+  const runtimeValues = {
+    CX_TOOLKIT_DIR: ROOT_DIR,
+    ...resolvedValues,
+  };
   const openCodeId = getOpenCodeMcpId(id);
 
-  if (id === "memory") {
-    return {
-      id: openCodeId,
-      entry: {
-        type: "local",
-        command: ["npx", "-y", "@modelcontextprotocol/server-memory@latest"],
-      },
-    };
-  }
-
   if (mcpDef.type === "url") {
-    const headers = buildRemoteHeaders(mcpDef, resolvedValues);
+    const url =
+      id === "memory" && runtimeValues.MEMORY_PORT
+        ? `http://127.0.0.1:${runtimeValues.MEMORY_PORT}/`
+        : resolveTemplateString(mcpDef.url, runtimeValues);
     return {
       id: openCodeId,
       entry: {
         type: "remote",
-        url: resolveTemplateString(mcpDef.url, resolvedValues),
-        ...(Object.keys(headers).length > 0 ? { headers } : {}),
+        url,
+        ...(Object.keys(buildRemoteHeaders(mcpDef, runtimeValues)).length > 0 ? { headers: buildRemoteHeaders(mcpDef, runtimeValues) } : {}),
       },
     };
   }
 
-  const environment = buildLocalEnvironment(mcpDef, resolvedValues);
+  const environment = buildLocalEnvironment(mcpDef, runtimeValues);
   return {
     id: openCodeId,
     entry: {
       type: "local",
-      command: [mcpDef.command, ...resolveArgs(mcpDef.args, resolvedValues)],
+      command: [mcpDef.command, ...resolveArgs(mcpDef.args, runtimeValues)],
       ...(Object.keys(environment).length > 0 ? { environment } : {}),
     },
   };

package/lib/memory-stats.mjs

@@ -0,0 +1,121 @@
+/**
+ * lib/memory-stats.mjs — memory layer usage statistics and JSONL snapshot appender.
+ *
+ * Reads .cx/memory-stats.jsonl (one JSON line per session) and computes aggregates:
+ * queries/session, avg observations injected, p95 retrieval latency, hit rate.
+ * appendSessionStats() is called at session end to record the current session.
+ *
+ * Stats are approximated from session-start injection counts and search call counts
+ * recorded by the observation store instrumentation. CONSTRUCT_MEMORY=off skips injection
+ * but still records a zero-hit entry so A/B comparisons are possible.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const STATS_FILE = '.cx/memory-stats.jsonl';
+
+function statsPath(rootDir) {
+  return path.join(rootDir, STATS_FILE);
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+}
+
+function readLines(rootDir) {
+  const p = statsPath(rootDir);
+  if (!fs.existsSync(p)) return [];
+  return fs.readFileSync(p, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => { try { return JSON.parse(line); } catch { return null; } })
+    .filter(Boolean);
+}
+
+/**
+ * Append one session's memory stats to the JSONL log.
+ * Fields: sessionId, project, at, queriesIssued, observationsInjected,
+ *         retrievalMs (p50 estimate), memoryEnabled.
+ */
+export function appendSessionStats(rootDir, {
+  sessionId = null,
+  project = null,
+  queriesIssued = 0,
+  observationsInjected = 0,
+  retrievalMs = null,
+  memoryEnabled = true,
+} = {}) {
+  const entry = {
+    sessionId,
+    project,
+    at: new Date().toISOString(),
+    queriesIssued,
+    observationsInjected,
+    retrievalMs,
+    memoryEnabled,
+  };
+  const p = statsPath(rootDir);
+  ensureDir(p);
+  fs.appendFileSync(p, JSON.stringify(entry) + '\n');
+  return entry;
+}
+
+/**
+ * Compute aggregate stats from the JSONL log.
+ * Returns { sessions, avgQueriesPerSession, avgInjectedPerSession,
+ *           p95RetrievalMs, hitRate, memoryEnabledPct }.
+ */
+export function computeStats(rootDir, { project = null, lastN = 50 } = {}) {
+  let lines = readLines(rootDir);
+  if (project) lines = lines.filter((l) => l.project === project);
+  lines = lines.slice(-lastN);
+
+  if (!lines.length) {
+    return { sessions: 0, avgQueriesPerSession: 0, avgInjectedPerSession: 0, p95RetrievalMs: null, hitRate: 0, memoryEnabledPct: 100 };
+  }
+
+  const sessions = lines.length;
+  const totalQueries = lines.reduce((s, l) => s + (l.queriesIssued || 0), 0);
+  const totalInjected = lines.reduce((s, l) => s + (l.observationsInjected || 0), 0);
+  const enabledCount = lines.filter((l) => l.memoryEnabled !== false).length;
+
+  const latencies = lines
+    .map((l) => l.retrievalMs)
+    .filter((v) => typeof v === 'number' && v > 0)
+    .sort((a, b) => a - b);
+
+  const p95RetrievalMs = latencies.length
+    ? latencies[Math.floor(latencies.length * 0.95)]
+    : null;
+
+  const sessionsWithHits = lines.filter((l) => (l.observationsInjected || 0) > 0).length;
+  const hitRate = sessions > 0 ? Math.round((sessionsWithHits / sessions) * 100) : 0;
+
+  return {
+    sessions,
+    avgQueriesPerSession: Math.round((totalQueries / sessions) * 10) / 10,
+    avgInjectedPerSession: Math.round((totalInjected / sessions) * 10) / 10,
+    p95RetrievalMs,
+    hitRate,
+    memoryEnabledPct: Math.round((enabledCount / sessions) * 100),
+  };
+}
+
+/**
+ * Format stats for terminal display.
+ */
+export function formatStats(stats) {
+  if (stats.sessions === 0) {
+    return '  No memory stats recorded yet. Run a few sessions and try again.\n';
+  }
+  const lines = [
+    `  Sessions tracked:      ${stats.sessions}`,
+    `  Avg queries/session:   ${stats.avgQueriesPerSession}`,
+    `  Avg injected/session:  ${stats.avgInjectedPerSession}`,
+    `  Hit rate:              ${stats.hitRate}%`,
+    `  p95 retrieval latency: ${stats.p95RetrievalMs != null ? `${stats.p95RetrievalMs}ms` : 'n/a'}`,
+    `  Memory enabled:        ${stats.memoryEnabledPct}% of sessions`,
+  ];
+  return lines.join('\n') + '\n';
+}

package/lib/mode-commands.mjs

@@ -0,0 +1,124 @@
+/**
+ * lib/mode-commands.mjs — Standardized command contracts across deployment modes.
+ *
+ * Provides mode-aware command execution for intake, memory, and workflow operations.
+ * Routes to file-based implementations in solo mode, Postgres in team/enterprise mode.
+ */
+
+// lib/mode-commands.mjs
+// Standardized command contracts across deployment modes
+
+import { spawnSync } from 'node:child_process';
+
+export const MODE_COMMANDS = {
+  // Intake queue operations
+  intake: {
+    list: async (options = {}) => {
+      const mode = getDeploymentMode();
+      
+      if (mode === 'solo') {
+        // File-based intake
+        const result = spawnSync('find', ['.cx/intake/pending', '-name', '*.json', '-type', 'f'], 
+          { encoding: 'utf8', cwd: options.cwd });
+        return parseIntakeFiles(result.stdout);
+      } else {
+        // Postgres-based intake
+        return queryPostgresIntake(options);
+      }
+    },
+    
+    show: async (id, options = {}) => {
+      const mode = getDeploymentMode();
+      
+      if (mode === 'solo') {
+        return readIntakeFile(id, options);
+      } else {
+        return queryPostgresIntakeItem(id, options);
+      }
+    },
+  },
+  
+  // Storage operations
+  storage: {
+    sync: async (options = {}) => {
+      const mode = getDeploymentMode();
+      
+      // Same interface, different implementation
+      if (mode === 'solo') {
+        return syncToFileStorage(options);
+      } else {
+        return syncToPostgresStorage(options);
+      }
+    },
+    
+    query: async (criteria, options = {}) => {
+      // Unified query interface
+      return queryStorage(criteria, options);
+    },
+  },
+};
+
+function getDeploymentMode() {
+  return process.env.CONSTRUCT_DEPLOYMENT_MODE || 'solo';
+}
+
+function parseIntakeFiles(stdout) {
+  return stdout.split('\n')
+    .filter(Boolean)
+    .map(f => ({ id: path.basename(f, '.json'), source: 'file' }));
+}
+
+function readIntakeFile(id, options) {
+  const fs = require('fs');
+  const path = require('path');
+  const filePath = path.join(options.cwd || process.cwd(), '.cx/intake/pending', `${id}.json`);
+  
+  if (!fs.existsSync(filePath)) {
+    return { error: `Intake item ${id} not found` };
+  }
+  
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+async function queryPostgresIntake(options) {
+  // Would use SQL client
+  return { items: [], mode: 'postgres' };
+}
+
+async function queryPostgresIntakeItem(id, options) {
+  return { id, mode: 'postgres' };
+}
+
+async function syncToFileStorage(options) {
+  return { 
+    success: true, 
+    mode: 'solo',
+    backend: 'file',
+  };
+}
+
+async function syncToPostgresStorage(options) {
+  return {
+    success: true,
+    mode: 'team',
+    backend: 'postgres',
+  };
+}
+
+async function queryStorage(criteria, options) {
+  // Unified query - works across modes
+  return {
+    results: [],
+    mode: getDeploymentMode(),
+  };
+}
+
+export function getCommandInterface(command, operation) {
+  const cmd = MODE_COMMANDS[command];
+  if (!cmd) return null;
+  
+  const fn = cmd[operation];
+  if (!fn) return null;
+  
+  return fn;
+}