@jagilber-org/index-server 1.22.1 → 1.26.1

package/dist/server/index-server.js

@@ -32,6 +32,11 @@ exports.startDashboard = startDashboard;
 // and then re-emit the buffered chunks once the SDK has attached its handlers.
 // This ensures spec compliance: an initialize request always yields either a
 // success or a version negotiation error – never silent drop.
+// Install MCP log bridge stderr intercept FIRST — before any module writes to stderr.
+// This buffers all stderr output and replays it through MCP notifications/message
+// after the handshake, so VS Code shows proper [info]/[warning]/[error] levels
+// instead of tagging everything as [warning] [server stderr].
+require("../services/mcpLogBridge");
 // Install global stderr log prefix (timestamps, pid, ppid, seq, tid) before any diagnostic output.
 require("../services/logPrefix");
 // Ensure logger initializes early (file logging environment may auto-resolve)
@@ -88,7 +93,10 @@ const path_1 = __importDefault(require("path"));
 const logger_1 = require("../services/logger");
 const bootstrapGating_1 = require("../services/bootstrapGating");
 const preflight_1 = require("../services/preflight");
+const child_process_1 = require("child_process");
 const shutdownGuard_1 = require("./shutdownGuard");
+const certInit_1 = require("./certInit");
+const certInit_types_1 = require("./certInit.types");
 // Singleton shutdown guard — all exit paths funnel through this (Issue #36 fix)
 exports.shutdownGuard = (0, shutdownGuard_1.createShutdownGuard)();
 // Store in global symbol so services (indexContext) can register cleanup without circular imports
@@ -223,12 +231,18 @@ function parseArgs(argv) {
             config.dashboard = true;
         else if (raw === '--no-dashboard')
             config.dashboard = false;
-        else if (raw.startsWith('--dashboard-port='))
-            config.dashboardPort = parseInt(raw.split('=')[1], 10) || config.dashboardPort;
+        else if (raw.startsWith('--dashboard-port=')) {
+            const parsed = parseInt(raw.split('=')[1], 10);
+            if (!Number.isNaN(parsed))
+                config.dashboardPort = parsed;
+        }
         else if (raw === '--dashboard-port') {
             const v = args[++i];
-            if (v)
-                config.dashboardPort = parseInt(v, 10) || config.dashboardPort;
+            if (v) {
+                const parsed = parseInt(v, 10);
+                if (!Number.isNaN(parsed))
+                    config.dashboardPort = parsed;
+            }
         }
         else if (raw.startsWith('--dashboard-host='))
             config.dashboardHost = raw.split('=')[1] || config.dashboardHost;
@@ -267,14 +281,103 @@ function parseArgs(argv) {
             if (v)
                 config.dashboardTlsCa = v;
         }
+        // ── --init-cert family ───────────────────────────────────────────────
+        else if (raw === '--init-cert')
+            config.initCert = true;
+        else if (raw.startsWith('--cert-dir='))
+            config.certDir = raw.split('=').slice(1).join('=');
+        else if (raw === '--cert-dir') {
+            const v = args[++i];
+            if (v)
+                config.certDir = v;
+        }
+        else if (raw.startsWith('--cert-file='))
+            config.certFile = raw.split('=').slice(1).join('=');
+        else if (raw === '--cert-file') {
+            const v = args[++i];
+            if (v)
+                config.certFile = v;
+        }
+        else if (raw.startsWith('--key-file='))
+            config.keyFile = raw.split('=').slice(1).join('=');
+        else if (raw === '--key-file') {
+            const v = args[++i];
+            if (v)
+                config.keyFile = v;
+        }
+        else if (raw.startsWith('--cn='))
+            config.certCn = raw.split('=').slice(1).join('=');
+        else if (raw === '--cn') {
+            const v = args[++i];
+            if (v)
+                config.certCn = v;
+        }
+        else if (raw.startsWith('--san='))
+            config.certSan = raw.split('=').slice(1).join('=');
+        else if (raw === '--san') {
+            const v = args[++i];
+            if (v)
+                config.certSan = v;
+        }
+        else if (raw.startsWith('--days=')) {
+            const p = parseInt(raw.split('=')[1], 10);
+            if (!Number.isNaN(p))
+                config.certDays = p;
+        }
+        else if (raw === '--days') {
+            const v = args[++i];
+            if (v) {
+                const p = parseInt(v, 10);
+                if (!Number.isNaN(p))
+                    config.certDays = p;
+            }
+        }
+        else if (raw.startsWith('--key-bits=')) {
+            const p = parseInt(raw.split('=')[1], 10);
+            if (!Number.isNaN(p))
+                config.certKeyBits = p;
+        }
+        else if (raw === '--key-bits') {
+            const v = args[++i];
+            if (v) {
+                const p = parseInt(v, 10);
+                if (!Number.isNaN(p))
+                    config.certKeyBits = p;
+            }
+        }
+        else if (raw === '--force')
+            config.certForce = true;
+        else if (raw === '--print-env')
+            config.certPrintEnv = true;
+        else if (raw.startsWith('--print-env='))
+            config.certPrintEnv = raw.split('=').slice(1).join('=');
+        else if (raw === '--start')
+            config.start = true;
         else if (raw === '--legacy' || raw === '--legacy-transport')
             config.legacy = true; // no-op
+        else if (raw === '--setup' || raw === '--configure') {
+            launchSetupWizard(argv);
+        }
         else if (raw === '--help' || raw === '-h') {
             printHelpAndExit();
         }
     }
     return config;
 }
+function launchSetupWizard(argv) {
+    const wizardPath = path_1.default.join(__dirname, '..', '..', 'scripts', 'setup-wizard.mjs');
+    // Forward all args after --setup/--configure to the wizard
+    const setupIdx = argv.findIndex(a => a === '--setup' || a === '--configure');
+    const forwardArgs = setupIdx >= 0 ? argv.slice(setupIdx + 1) : [];
+    try {
+        (0, child_process_1.execFileSync)(process.execPath, [wizardPath, ...forwardArgs], { stdio: 'inherit' });
+    }
+    catch (e) {
+        const code = e.status ?? 1;
+        process.exit(code);
+    }
+    process.exit(0);
+}
 function printHelpAndExit() {
     const help = `index-server - Model Context Protocol Server
 
@@ -283,6 +386,10 @@ MCP TRANSPORT (Client Communication):
   Purpose: VS Code, Claude, and other MCP clients
   Security: Process-isolated, no network exposure
 
+SETUP:
+  --setup                  Launch interactive configuration wizard
+  --configure              Alias for --setup
+
 ADMIN DASHBOARD (Optional):
   --dashboard              Enable read-only admin dashboard (default off)
   --dashboard-port=PORT    Dashboard port (default 8787)
@@ -295,6 +402,23 @@ ADMIN DASHBOARD (Optional):
   --dashboard-tls-ca=PATH    Optional CA certificate file (PEM)
   Purpose: Local administrator monitoring only
 
+CERTIFICATE BOOTSTRAP (Optional, Self-Signed TLS):
+  --init-cert              Generate a self-signed TLS cert+key (requires openssl on PATH).
+                           Exits after generation unless --start is also given.
+  --cert-dir PATH          Output directory (default: ~/.index-server/certs)
+  --cert-file PATH         Override cert output path (must be under --cert-dir)
+  --key-file PATH          Override key output path (must be under --cert-dir)
+  --cn NAME                CommonName subject (default: localhost)
+  --san LIST               Comma-separated SAN entries (default: DNS:localhost,IP:127.0.0.1)
+  --days N                 Validity in days, 1..3650 (default: 365)
+  --key-bits N             RSA key size, 2048 or 4096 (default: 2048)
+  --force                  Overwrite existing cert/key files
+  --print-env[=FMT]        Print INDEX_SERVER_DASHBOARD_TLS_* env lines after generation.
+                           FMT = posix | powershell | both | auto (default: auto)
+  --start                  After --init-cert, start the server with the generated material
+                           (sets --dashboard-tls and feeds the new cert/key automatically)
+  See docs/cert_init.md for full reference, examples, and security notes.
+
 ENVIRONMENT VARIABLES:
   INDEX_SERVER_DASHBOARD=1          Enable dashboard (0=disable, 1=enable)
   INDEX_SERVER_DASHBOARD_PORT=PORT  Dashboard port (default 8787)
@@ -308,7 +432,7 @@ ENVIRONMENT VARIABLES:
   Other environment variables:
   INDEX_SERVER_VERBOSE_LOGGING=1   Verbose RPC/transport logging
   INDEX_SERVER_LOG_DIAG=1           Diagnostic logging
-  INDEX_SERVER_MUTATION=1           Enable write operations
+  INDEX_SERVER_MUTATION=0           Force read-only mode (writes enabled by default)
   INDEX_SERVER_IDLE_KEEPALIVE_MS    Keepalive interval (default 30000ms)
   NODE_ENV=development              Use dev ports (dashboard=${defaultValues_1.DEFAULT_PORTS.DASHBOARD_DEV}, leader=${defaultValues_1.DEFAULT_PORTS.LEADER_DEV})
 
@@ -484,10 +608,72 @@ async function main() {
     // observes the synthetic readiness sentinel. The interval self-clears on first
     // stdin activity or after the bounded max window.
     startIdleKeepalive();
-    // Short-circuit handshake mode removed (INDEX_SERVER_SHORTCIRCUIT) now that full
-    // protocol framing is stable and locked by tests. (2025-08-31)
     const cfg = parseArgs(process.argv);
     const runtime = (0, runtimeConfig_1.getRuntimeConfig)();
+    // ── --init-cert dispatch ──────────────────────────────────────────────
+    // Self-contained: if --init-cert is given, run cert generation. When --start
+    // is NOT also given, exit after generation (or on error). When --start IS
+    // given, inject the generated paths into the dashboard TLS config so the
+    // server boots with the new material — no extra env wiring required.
+    // Constitution refs: AR-1 (additive, no implicit side effects without flag),
+    // SH-4 (path traversal guard re-asserted by validateOptions inside runCertInit),
+    // OB-3/OB-5 (CertInitError surfaced with stable code; structured logs from module).
+    if (cfg.initCert) {
+        try {
+            const result = await (0, certInit_1.runCertInit)({
+                certDir: cfg.certDir,
+                certFile: cfg.certFile,
+                keyFile: cfg.keyFile,
+                cn: cfg.certCn,
+                san: cfg.certSan,
+                days: cfg.certDays,
+                keyBits: cfg.certKeyBits,
+                force: cfg.certForce ?? false,
+                printEnv: (cfg.certPrintEnv ?? false),
+            });
+            process.stderr.write(`[init-cert] ${result.kind === 'generated' ? 'generated' : 'skipped'}: cert=${result.certFile} key=${result.keyFile}\n`);
+            if (cfg.certPrintEnv) {
+                const fmt = (typeof cfg.certPrintEnv === 'string')
+                    ? cfg.certPrintEnv
+                    : 'auto';
+                // Re-validate to obtain the resolved option shape (paths) for the helper.
+                const opts = (0, certInit_1.validateOptions)({
+                    certDir: cfg.certDir,
+                    certFile: result.certFile,
+                    keyFile: result.keyFile,
+                    cn: cfg.certCn,
+                    san: cfg.certSan,
+                    days: cfg.certDays,
+                    keyBits: cfg.certKeyBits,
+                    force: cfg.certForce ?? false,
+                    printEnv: (cfg.certPrintEnv ?? false),
+                });
+                process.stderr.write((0, certInit_1.formatPrintEnv)(opts, fmt));
+            }
+            // When --start was passed, inject paths into the dashboard TLS config
+            // so startDashboard() picks them up without requiring --dashboard-tls-cert/key.
+            if (cfg.start) {
+                cfg.dashboardTls = true;
+                cfg.dashboardTlsCert = result.certFile;
+                cfg.dashboardTlsKey = result.keyFile;
+                // Continue normal startup below.
+            }
+            else {
+                // Generation-only mode: exit cleanly.
+                process.exit(0);
+            }
+        }
+        catch (e) {
+            const code = (e instanceof certInit_types_1.CertInitError) ? e.code : 'UNKNOWN';
+            const msg = (e instanceof Error) ? e.message : String(e);
+            process.stderr.write(`[init-cert] FAILED (code=${code}): ${msg}\n`);
+            try {
+                (0, logger_1.logError)('[init-cert] failed', { code, message: msg });
+            }
+            catch { /* ignore */ }
+            process.exit(2);
+        }
+    }
     // ── Dev/prod port-collision guard ─────────────────────────────────
     // When NODE_ENV=development (or --watch), refuse to start on production
     // default ports to prevent dev servers from receiving production traffic.
@@ -597,9 +783,8 @@ async function main() {
                     catch { /* ignore */ }
                 }
             }
-            // eslint-disable-next-line no-console
             if (runtime.logging.diagnostics)
-                console.error(`[handshake-buffer] replayed ${__earlyInitChunks.length} early chunk(s)`);
+                (0, logger_1.logError)(`[handshake-buffer] replayed ${__earlyInitChunks.length} early chunk(s)`);
             __earlyInitChunks.length = 0;
         }
         else if (runtime.logging.diagnostics) {

package/dist/server/mcpReadOnlySurfaces.d.ts

@@ -0,0 +1,44 @@
+type PromptArgument = {
+    name: string;
+    description?: string;
+    required?: boolean;
+};
+export declare function getReadOnlySurfaceCapabilities(): {
+    prompts: {
+        listChanged: boolean;
+    };
+    resources: {
+        listChanged: boolean;
+    };
+};
+export declare function listReadOnlyResources(): {
+    uri: string;
+    name: string;
+    title?: string;
+    description: string;
+    mimeType: "text/markdown";
+}[];
+export declare function readReadOnlyResource(uri: string): {
+    contents: {
+        uri: string;
+        mimeType: "text/markdown";
+        text: string;
+    }[];
+} | null;
+export declare function listReadOnlyPrompts(): {
+    name: string;
+    title?: string;
+    description: string;
+    arguments?: PromptArgument[];
+}[];
+export declare function getReadOnlyPrompt(name: string, args?: Record<string, string>): {
+    description?: string;
+    messages: Array<{
+        role: "user" | "assistant";
+        content: {
+            type: "text";
+            text: string;
+        };
+    }>;
+} | null;
+export {};

package/dist/server/mcpReadOnlySurfaces.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReadOnlySurfaceCapabilities = getReadOnlySurfaceCapabilities;
+exports.listReadOnlyResources = listReadOnlyResources;
+exports.readReadOnlyResource = readReadOnlyResource;
+exports.listReadOnlyPrompts = listReadOnlyPrompts;
+exports.getReadOnlyPrompt = getReadOnlyPrompt;
+function normalizeClientTarget(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    if (!normalized)
+        return 'generic';
+    if (normalized.includes('code') || normalized.includes('vscode') || normalized.includes('vs code'))
+        return 'vscode';
+    if (normalized.includes('copilot'))
+        return 'copilot-cli';
+    if (normalized.includes('claude'))
+        return 'claude';
+    return 'generic';
+}
+function clientLabel(target) {
+    switch (normalizeClientTarget(target)) {
+        case 'vscode':
+            return 'VS Code';
+        case 'copilot-cli':
+            return 'Copilot CLI';
+        case 'claude':
+            return 'Claude Desktop';
+        default:
+            return 'your MCP client';
+    }
+}
+function clientConfigPath(target) {
+    switch (normalizeClientTarget(target)) {
+        case 'vscode':
+            return '.vscode/mcp.json (workspace) or User/mcp.json (global)';
+        case 'copilot-cli':
+            return '~/.copilot/mcp-config.json';
+        case 'claude':
+            return 'claude_desktop_config.json';
+        default:
+            return 'the MCP client config file for your environment';
+    }
+}
+function clientConfigRoot(target) {
+    switch (normalizeClientTarget(target)) {
+        case 'vscode':
+            return '`servers`';
+        case 'copilot-cli':
+        case 'claude':
+            return '`mcpServers`';
+        default:
+            return '`servers` or `mcpServers` depending on the client';
+    }
+}
+const STATIC_RESOURCES = [
+    {
+        uri: 'index://guides/quickstart',
+        name: 'quickstart',
+        title: 'Quick Start',
+        description: 'Install, configure, and verify Index Server with the MCP-native flow.',
+        mimeType: 'text/markdown',
+        text: [
+            '# Index Server Quick Start',
+            '',
+            '## Recommended install',
+            '',
+            '```bash',
+            'npx -y @jagilber-org/index-server@latest --setup',
+            '```',
+            '',
+            'Use the setup wizard to generate MCP client config for VS Code, Copilot CLI, or Claude Desktop.',
+            '',
+            '## Manual configuration',
+            '',
+            '- Use `npx` with `@jagilber-org/index-server@latest` as the command target.',
+            '- Keep `INDEX_SERVER_DIR` in a stable data folder outside client install/config directories.',
+            '- Add `--dashboard` or `--dashboard-port=8787` if you want the admin UI enabled.',
+            '',
+            '## Verification',
+            '',
+            '1. Restart the MCP client.',
+            '2. Confirm the server appears in the MCP server list.',
+            '3. Ask the client to run `health_check`.',
+            '4. Ask the client to run `bootstrap` / `index-server-bootstrap status` to confirm initialization state.',
+        ].join('\n'),
+    },
+    {
+        uri: 'index://guides/client-config',
+        name: 'client-config',
+        title: 'Client Configuration',
+        description: 'Config file formats and best practices for VS Code, Copilot CLI, and Claude Desktop.',
+        mimeType: 'text/markdown',
+        text: [
+            '# MCP Client Configuration',
+            '',
+            '## File formats',
+            '',
+            '- **VS Code** uses `.vscode/mcp.json` (workspace) or User `mcp.json` with a `servers` root key.',
+            '- **Copilot CLI** uses `~/.copilot/mcp-config.json` with an `mcpServers` root key.',
+            '- **Claude Desktop** uses `claude_desktop_config.json` with an `mcpServers` root key.',
+            '',
+            '## Best practices',
+            '',
+            '- Prefer `npx -y @jagilber-org/index-server@latest` for published installs.',
+            '- Set `INDEX_SERVER_DIR` to a persistent data directory such as `C:/mcp/index-data/instructions`.',
+            '- For Copilot CLI and Claude Desktop, include `cwd` when you are running a local checkout instead of the published package.',
+            '- For Copilot CLI, `tools: ["*"]` keeps all tools available.',
+            '',
+            '## Setup wizard targets',
+            '',
+            '- `--target vscode`',
+            '- `--target copilot-cli`',
+            '- `--target claude`',
+            '- multiple targets are supported with comma-separated values',
+        ].join('\n'),
+    },
+    {
+        uri: 'index://guides/verification',
+        name: 'verification',
+        title: 'Verification and Troubleshooting',
+        description: 'Checklist for verifying the MCP connection and diagnosing common setup issues.',
+        mimeType: 'text/markdown',
+        text: [
+            '# Verification and Troubleshooting',
+            '',
+            '## Basic checks',
+            '',
+            '1. Restart the MCP client after config changes.',
+            '2. Confirm the server is listed in the client UI.',
+            '3. Run `tools/list` to confirm tool discovery.',
+            '4. Run `health_check` to confirm the server is reachable.',
+            '5. Run bootstrap status if initialization looks gated on a fresh install.',
+            '',
+            '## Common causes',
+            '',
+            '- The config file uses the wrong root key (`servers` vs `mcpServers`).',
+            '- `cwd` is missing for a local checkout configuration.',
+            '- `INDEX_SERVER_DIR` points at a transient or client-owned directory.',
+            '- The client was not restarted after editing the config.',
+            '- The command path references a local build that has not been built yet.',
+        ].join('\n'),
+    },
+];
+const RESOURCE_BY_URI = new Map(STATIC_RESOURCES.map((resource) => [resource.uri, resource]));
+function renderSetupPrompt(args) {
+    const client = clientLabel(args?.client);
+    const configPath = clientConfigPath(args?.client);
+    const configRoot = clientConfigRoot(args?.client);
+    return {
+        description: `Guide ${client} setup with the MCP-native install flow.`,
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Help me install and configure Index Server for ${client}. Prefer the published MCP-native flow.`,
+                },
+            },
+            {
+                role: 'assistant',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Use \`npx -y @jagilber-org/index-server@latest --setup\` first so ${client} configuration is generated automatically when possible.`,
+                        `If the user needs manual setup, edit ${configPath} and use the ${configRoot} root key.`,
+                        'Keep `INDEX_SERVER_DIR` in a stable data folder outside the MCP client install/config path.',
+                        'After configuration, restart the client and verify with `health_check` and bootstrap status.',
+                        'Reference resources: `index://guides/quickstart`, `index://guides/client-config`, `index://guides/verification`.',
+                    ].join('\n'),
+                },
+            },
+        ],
+    };
+}
+function renderConfigPrompt(args) {
+    const client = clientLabel(args?.client);
+    const configPath = clientConfigPath(args?.client);
+    const configRoot = clientConfigRoot(args?.client);
+    return {
+        description: `Explain the right MCP config shape for ${client}.`,
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Review or generate the MCP configuration for ${client}.`,
+                },
+            },
+            {
+                role: 'assistant',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Target config file: ${configPath}.`,
+                        `Use ${configRoot} as the root key for this client.`,
+                        'Prefer `npx -y @jagilber-org/index-server@latest` for published installs.',
+                        'Use `cwd` only for local checkout configurations that run `dist/server/index-server.js`.',
+                        'Set `INDEX_SERVER_DIR` to a persistent directory and keep env values as strings.',
+                        'Reference resource: `index://guides/client-config`.',
+                    ].join('\n'),
+                },
+            },
+        ],
+    };
+}
+function renderVerificationPrompt(args) {
+    const symptom = String(args?.symptom ?? 'the MCP client is not behaving as expected')
+        .trim()
+        .slice(0, 500);
+    return {
+        description: 'Walk through a quick verification and troubleshooting checklist.',
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Help me troubleshoot Index Server because ${symptom}.`,
+                },
+            },
+            {
+                role: 'assistant',
+                content: {
+                    type: 'text',
+                    text: [
+                        'Start with protocol-level checks: confirm the server appears in the MCP client and that `tools/list` succeeds.',
+                        'Then run `health_check` and bootstrap status to separate connectivity problems from initialization state.',
+                        'Verify the config file uses the correct root key and includes `cwd` for local checkout setups.',
+                        'If configuration changed recently, restart the MCP client before concluding the server is broken.',
+                        'Reference resource: `index://guides/verification`.',
+                    ].join('\n'),
+                },
+            },
+        ],
+    };
+}
+const PROMPTS = [
+    {
+        name: 'setup_index_server',
+        title: 'Setup Index Server',
+        description: 'Guide an MCP-native Index Server install and initial configuration.',
+        arguments: [
+            { name: 'client', description: 'Optional target client such as vscode, copilot-cli, or claude.' },
+        ],
+        render: renderSetupPrompt,
+    },
+    {
+        name: 'configure_index_server',
+        title: 'Configure Index Server',
+        description: 'Explain the right config file shape and key settings for a target client.',
+        arguments: [
+            { name: 'client', description: 'Optional target client such as vscode, copilot-cli, or claude.' },
+        ],
+        render: renderConfigPrompt,
+    },
+    {
+        name: 'verify_index_server',
+        title: 'Verify Index Server',
+        description: 'Walk through verification and troubleshooting for setup or connection issues.',
+        arguments: [
+            { name: 'symptom', description: 'Optional short problem statement to tailor the checklist.' },
+        ],
+        render: renderVerificationPrompt,
+    },
+];
+const PROMPT_BY_NAME = new Map(PROMPTS.map((prompt) => [prompt.name, prompt]));
+function getReadOnlySurfaceCapabilities() {
+    return {
+        prompts: { listChanged: false },
+        resources: { listChanged: false },
+    };
+}
+function listReadOnlyResources() {
+    return STATIC_RESOURCES.map(({ text: _text, ...resource }) => resource);
+}
+function readReadOnlyResource(uri) {
+    const resource = RESOURCE_BY_URI.get(uri);
+    if (!resource)
+        return null;
+    return {
+        contents: [
+            {
+                uri: resource.uri,
+                mimeType: resource.mimeType,
+                text: resource.text,
+            },
+        ],
+    };
+}
+function listReadOnlyPrompts() {
+    return PROMPTS.map(({ render: _render, ...prompt }) => prompt);
+}
+function getReadOnlyPrompt(name, args) {
+    const prompt = PROMPT_BY_NAME.get(name);
+    if (!prompt)
+        return null;
+    return prompt.render(args);
+}