@insightsentry/mcp 1.4.39 → 1.4.41

package/dist/cli.js

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
@@ -14,15 +15,21 @@ import { downloadHistory, validateOutputDirectory, } from "./history.js";
 import { validateHistoryIntervalArgs } from "./history-validation.js";
 import { PACKAGE_JSON } from "./package-info.js";
 import { supportsCsvStorage, validateResponseStorageTarget, } from "./response-storage.js";
+import { createStreamOutput, } from "./stream-output.js";
 import { analyzeSymbolCodes, shouldPromptSymbolScopedParam } from "./symbol-param-applicability.js";
 import { validateSymbolLikeArg } from "./symbol-validation.js";
 import { toolDefinitions } from "./tool-definitions.js";
 import { runApiTool, validateFilterExpression } from "./tool-runner.js";
 import { fetchLatestPackageVersion, formatUpgradeNotice, formatVersionStatus, getVersionStatus, } from "./version-status.js";
+import { buildLiveStreamRequest, buildNewsfeedStreamRequest, } from "./websocket-contract.js";
+import { LIVE_STREAM_SCHEMA, NEWSFEED_STREAM_SCHEMA, STREAM_OUTPUT_SCHEMA, } from "./websocket-schemas.js";
+import { runWebSocketStream, } from "./websocket-stream.js";
 export { coerceArgs } from "./arg-coercion.js";
 const DOWNLOAD_HISTORY_COMMAND = "download_history";
 const GET_SYMBOL_HISTORY_COMMAND = "get_symbol_history";
 const RENDER_CHART_COMMAND = "render_chart";
+const STREAM_LIVE_COMMAND = "stream_live";
+const STREAM_NEWSFEED_COMMAND = "stream_newsfeed";
 const UPDATE_COMMAND = "update";
 const VERSION_COMMAND = "version";
 const MAX_INTERACTIVE_PROMPT_ATTEMPTS = 3;
@@ -71,6 +78,7 @@ const RENDER_CHART_SCHEMA = {
 };
 export function parseArgs(argv) {
     const args = {};
+    const valuelessArgs = new Set();
     let toolName = null;
     let help = false;
     let version = false;
@@ -97,10 +105,12 @@ export function parseArgs(argv) {
             const next = argv[i + 1];
             if (next === undefined || next.startsWith("--")) {
                 args[key] = "true";
+                valuelessArgs.add(key);
                 i++;
             }
             else {
                 args[key] = next;
+                valuelessArgs.delete(key);
                 i += 2;
             }
         }
@@ -108,7 +118,7 @@ export function parseArgs(argv) {
             i++;
         }
     }
-    return { toolName, args, help, version };
+    return { toolName, args, valuelessArgs: [...valuelessArgs], help, version };
 }
 export function buildVersion() {
     return `${PACKAGE_JSON.name} ${PACKAGE_JSON.version}`;
@@ -130,6 +140,8 @@ export function buildHelp() {
     lines.push(`  ${DOWNLOAD_HISTORY_COMMAND.padEnd(32)} Download historical ranges to JSON/CSV files with concurrency and progress`);
     lines.push(`  ${GET_SYMBOL_HISTORY_COMMAND.padEnd(32)} Same as download_history; downloads history to files`);
     lines.push(`  ${RENDER_CHART_COMMAND.padEnd(32)} Render Chart.js configs as PNG images`);
+    lines.push(`  ${STREAM_LIVE_COMMAND.padEnd(32)} Stream real-time market data as NDJSON`);
+    lines.push(`  ${STREAM_NEWSFEED_COMMAND.padEnd(32)} Stream financial news as NDJSON`);
     lines.push("");
     lines.push("Quick Start:");
     lines.push('  insight search_symbols --query "apple"');
@@ -139,6 +151,8 @@ export function buildHelp() {
     lines.push('  insight screen_stocks --fields "close,volume,market_cap" --exchanges "NYSE,NASDAQ" --sortBy market_cap --sortOrder desc');
     lines.push("  insight get_earnings --c US");
     lines.push('  insight get_options_contracts --code "NASDAQ:AAPL" --type call --range 10');
+    lines.push('  insight stream_live --symbols "NASDAQ:AAPL" --type both --bar_type minute --max_messages 100 --duration_seconds 30');
+    lines.push("  insight stream_newsfeed --output_file ./news.ndjson --append --duration_seconds 30");
     lines.push("");
     lines.push("API tools support --filter <jsonata> to transform the response.");
     lines.push("Use: insight <tool> --help for tool-specific parameters.");
@@ -201,6 +215,54 @@ export function buildRenderChartHelp() {
         '  insight render_chart --config \'{"type":"bar","data":{"labels":["Jan"],"datasets":[{"label":"Volume","data":[1200]}]}}\' --width 1200 --height 600',
     ].join("\n");
 }
+export function buildStreamHelp(commandName) {
+    const isLive = commandName === STREAM_LIVE_COMMAND;
+    const schema = isLive
+        ? { ...LIVE_STREAM_SCHEMA, ...STREAM_OUTPUT_SCHEMA }
+        : { ...NEWSFEED_STREAM_SCHEMA, ...STREAM_OUTPUT_SCHEMA };
+    const lines = [
+        `insight ${commandName}`,
+        "",
+        isLive
+            ? "Stream real-time quotes and series as newline-delimited JSON. Use --symbols with --type for common settings, or --subscriptions for per-symbol settings."
+            : "Stream matching financial news as newline-delimited JSON.",
+    ];
+    if (isLive) {
+        lines.push("", "Subscription modes:", "  Simple:     --symbols <codes> --type <quote|series|both>", "  Per-symbol: --subscriptions <json-array>");
+    }
+    lines.push("", "Parameters:");
+    for (const [key, zodType] of Object.entries(schema)) {
+        const requirement = isLive && key === "symbols"
+            ? "[required with --type]"
+            : isLive && key === "type"
+                ? "[required with --symbols]"
+                : isLive && key === "subscriptions"
+                    ? "[alternative to --symbols/--type]"
+                    : "[optional]";
+        lines.push(`  --${key.padEnd(24)} ${formatTypeName(zodType)} ${requirement}  ${formatHelpDescription(zodType)}`);
+    }
+    lines.push("", "Boolean options accept a bare flag or an explicit true/false value.", "Received WebSocket frames use stdout as NDJSON; CLI status and local errors use stderr.", "Use --quiet to suppress WebSocket status diagnostics for machine-readable terminal output.");
+    if (isLive) {
+        lines.push("Quote updates can be sparse; merge updates by code when maintaining a current snapshot.");
+    }
+    else {
+        lines.push("Populated filter fields are combined, so a news item must satisfy every populated field.", "Each initial connection and reconnection replays up to 10 recent matching news items before new items.");
+    }
+    lines.push("");
+    lines.push("Examples:");
+    if (isLive) {
+        lines.push('  insight stream_live --symbols "NASDAQ:AAPL,NASDAQ:MSFT" --type both --bar_type minute --bar_interval 1 --max_messages 100 --duration_seconds 30');
+        lines.push(`  insight stream_live --subscriptions '[{"code":"NASDAQ:AAPL","type":"series","bar_type":"day"},{"code":"NASDAQ:MSFT","type":"quote"}]' --output_file ./market.ndjson --append --duration_seconds 60`);
+    }
+    else {
+        lines.push("  insight stream_newsfeed --max_messages 20 --duration_seconds 30");
+        lines.push('  insight stream_newsfeed --content "earnings" --related_symbols "NASDAQ:AAPL" --output_file ./news.ndjson --append --duration_seconds 60');
+    }
+    lines.push("");
+    lines.push("Press Ctrl+C to close the socket after queued output is written.");
+    lines.push("Docs: https://insightsentry.com/docs/ws");
+    return lines.join("\n");
+}
 const toolExamples = {
     search_symbols: [
         'insight search_symbols --query "tesla"',
@@ -393,7 +455,7 @@ function isPromptAbortError(error) {
     return candidate.code === "ABORT_ERR" || candidate.name === "AbortError";
 }
 async function runCliInner(argv, io) {
-    let { toolName, args, help, version } = parseArgs(argv);
+    let { toolName, args, valuelessArgs, help, version } = parseArgs(argv);
     let sessionApiKey;
     if (version) {
         io.write(buildVersion());
@@ -466,6 +528,15 @@ async function runCliInner(argv, io) {
         }
         return;
     }
+    if (isStreamCommand(toolName)) {
+        if (help) {
+            io.write(buildStreamHelp(toolName));
+            io.exit(0);
+            return;
+        }
+        await runStreamCliCommand(toolName, args, valuelessArgs, sessionApiKey, io);
+        return;
+    }
     if (isHistoryDownloadCommand(toolName)) {
         if (help) {
             io.write(buildDownloadHistoryHelp(toolName));
@@ -701,6 +772,306 @@ async function resolveInteractiveToolName(io) {
     io.write("No tool selected.");
     return null;
 }
+async function runStreamCliCommand(commandName, args, valuelessArgs, sessionApiKey, io) {
+    const inputSchema = commandName === STREAM_LIVE_COMMAND ? LIVE_STREAM_SCHEMA : NEWSFEED_STREAM_SCHEMA;
+    const fullSchema = { ...inputSchema, ...STREAM_OUTPUT_SCHEMA };
+    const inputArgs = { ...args };
+    const guided = io.isInteractive === true && Boolean(io.prompt) && Object.keys(args).length === 0;
+    const unknownArg = Object.keys(inputArgs).find((key) => !(key in fullSchema));
+    if (unknownArg) {
+        const suggestion = closestStreamOption(unknownArg, Object.keys(fullSchema));
+        writeStreamError(io, `Error: Unknown option --${unknownArg}.${suggestion ? ` Did you mean --${suggestion}?` : ` Run: insight ${commandName} --help`}`);
+        io.exit(1);
+        return;
+    }
+    const validationErrors = collectInvalidStreamArgs(inputArgs, fullSchema, valuelessArgs);
+    if (validationErrors.length > 0) {
+        const validationError = validationErrors[0];
+        writeStreamError(io, `Invalid ${toolPromptLabel(validationError.key)}: ${validationError.error}`);
+        io.exit(1);
+        return;
+    }
+    const resolvedArgs = guided ? await resolveStreamArgs(commandName, inputArgs, io) : inputArgs;
+    if (!resolvedArgs) {
+        writeStreamError(io, `Error: Missing required streaming options.\n\nRun: insight ${commandName} --help`);
+        io.exit(1);
+        return;
+    }
+    const resolvedValidationError = validateStreamArgs(resolvedArgs, fullSchema);
+    if (resolvedValidationError) {
+        writeStreamError(io, `Invalid ${toolPromptLabel(resolvedValidationError.key)}: ${resolvedValidationError.error}`);
+        io.exit(1);
+        return;
+    }
+    const outputDependencyError = validateStreamOutputDependencies(resolvedArgs, fullSchema);
+    if (outputDependencyError) {
+        writeStreamError(io, `Error: ${outputDependencyError}`);
+        io.exit(1);
+        return;
+    }
+    const apiKey = sessionApiKey?.trim() || io.getApiKey?.()?.trim() || resolveApiKey();
+    if (!apiKey) {
+        writeStreamError(io, "Error: No API key found.\n\nSet it with:  insight login --key <your-api-key>\nOr export:    export INSIGHTSENTRY_API_KEY=your-api-key\n\nGet your API key from https://insightsentry.com/dashboard");
+        io.exit(1);
+        return;
+    }
+    try {
+        const knownArgs = pickKnownArgs(resolvedArgs, Object.keys(fullSchema));
+        const coerced = coerceArgs(knownArgs, fullSchema);
+        const request = commandName === STREAM_LIVE_COMMAND
+            ? buildLiveStreamRequest(pickStreamInput(coerced, LIVE_STREAM_SCHEMA), apiKey)
+            : buildNewsfeedStreamRequest(pickStreamInput(coerced, NEWSFEED_STREAM_SCHEMA), apiKey);
+        if (coerced.quiet !== true) {
+            reportArgUsage(io, knownArgs, Object.keys(fullSchema), inputArgs);
+        }
+        if (coerced.quiet !== true && request.ignoredArgs.length > 0) {
+            io.progress?.(`Ignoring inapplicable subscription args: ${request.ignoredArgs.join(", ")}`);
+        }
+        const outputFactory = io.createStreamOutput ?? createStreamOutput;
+        const streamOutput = await outputFactory({
+            outputFile: optionalString(coerced.output_file),
+            append: coerced.append === true,
+            tee: coerced.tee === true,
+        });
+        try {
+            const runner = io.runStream ?? runWebSocketStream;
+            const result = await runner({
+                request,
+                output: streamOutput,
+                diagnostics: coerced.quiet === true ? () => { } : io.progress,
+                signal: io.streamSignal,
+                maxReconnectAttempts: typeof coerced.max_reconnect_attempts === "number"
+                    ? coerced.max_reconnect_attempts
+                    : undefined,
+                durationMs: typeof coerced.duration_seconds === "number"
+                    ? coerced.duration_seconds * 1_000
+                    : undefined,
+                maxMessages: typeof coerced.max_messages === "number" ? coerced.max_messages : undefined,
+            });
+            io.exit(io.getStreamSignalExitCode?.() ?? result.exitCode);
+        }
+        catch (error) {
+            await streamOutput.close().catch(() => { });
+            throw error;
+        }
+    }
+    catch (error) {
+        writeStreamError(io, `Error: ${errorMessage(error)}`);
+        io.exit(1);
+    }
+}
+async function resolveStreamArgs(commandName, args, io) {
+    if (io.isInteractive !== true || !io.prompt)
+        return args;
+    const resolved = { ...args };
+    if (commandName === STREAM_LIVE_COMMAND) {
+        const symbols = await promptForToolArg("symbols", LIVE_STREAM_SCHEMA.symbols, io);
+        if (!symbols)
+            return null;
+        resolved.symbols = symbols;
+        const type = await promptForToolArg("type", LIVE_STREAM_SCHEMA.type, io);
+        if (!type)
+            return null;
+        resolved.type = type;
+        if (type === "series" || type === "both") {
+            const seriesSettings = await promptForStreamChoice("Series Settings", "Use server defaults or configure bar settings.", ["default", "custom"], "default", io);
+            if (!seriesSettings)
+                return null;
+            if (seriesSettings === "custom") {
+                const barType = await promptForToolArg("bar_type", LIVE_STREAM_SCHEMA.bar_type, io);
+                if (!barType)
+                    return null;
+                resolved.bar_type = barType;
+                for (const key of ["bar_interval", "dp"]) {
+                    const answer = await promptForOptionalToolArg(key, LIVE_STREAM_SCHEMA[key], io);
+                    if (answer === null)
+                        return null;
+                    if (answer !== undefined)
+                        resolved[key] = answer;
+                }
+            }
+        }
+        const advanced = await promptForStreamChoice("Advanced Settings", "Configure session, adjustment, currency, unit, or delivery options.", ["no", "yes"], "no", io);
+        if (!advanced)
+            return null;
+        if (advanced === "yes") {
+            for (const key of [
+                "currency",
+                "unit",
+                "extended",
+                "24h",
+                "split",
+                "dadj",
+                "badj",
+                "settlement",
+                "slow_consumer_policy",
+            ]) {
+                if (shouldSkipLiveStreamPrompt(key, type))
+                    continue;
+                const answer = await promptForOptionalToolArg(key, LIVE_STREAM_SCHEMA[key], io);
+                if (answer === null)
+                    return null;
+                if (answer !== undefined)
+                    resolved[key] = answer;
+            }
+        }
+    }
+    else {
+        const selection = await promptForStreamChoice("News Selection", "Stream all news or configure matching filters.", ["all", "filtered"], "all", io);
+        if (!selection)
+            return null;
+        if (selection === "filtered") {
+            for (const [key, zodType] of Object.entries(NEWSFEED_STREAM_SCHEMA)) {
+                const answer = await promptForOptionalToolArg(key, zodType, io);
+                if (answer === null)
+                    return null;
+                if (answer !== undefined)
+                    resolved[key] = answer;
+            }
+            if (!Object.keys(NEWSFEED_STREAM_SCHEMA).some((key) => hasArgValue(resolved[key]))) {
+                writeStreamError(io, "No newsfeed filters were entered; streaming all news.");
+            }
+        }
+    }
+    return (await resolveInteractiveStreamOutput(resolved, io)) ? resolved : null;
+}
+async function resolveInteractiveStreamOutput(resolved, io) {
+    const destination = await promptForStreamChoice("Output Destination", "Choose where received NDJSON messages are written.", ["terminal", "file", "both"], "terminal", io);
+    if (!destination)
+        return false;
+    if (destination === "terminal")
+        return true;
+    const outputFile = await promptForToolArg("output_file", STREAM_OUTPUT_SCHEMA.output_file, io);
+    if (!outputFile)
+        return false;
+    resolved.output_file = outputFile;
+    if (destination === "both")
+        resolved.tee = "true";
+    if (await pathExists(outputFile)) {
+        const existingFileAction = await promptForStreamChoice("Existing Output File", "Append to the existing file or replace it. Press Ctrl+C to cancel.", ["append", "replace"], "append", io);
+        if (!existingFileAction)
+            return false;
+        resolved.append = existingFileAction === "append" ? "true" : "false";
+    }
+    return true;
+}
+async function promptForStreamChoice(label, description, choices, defaultValue, io) {
+    const question = `${label}: ${description}\n${label} (choices: ${choices.join("/")}, Default: ${defaultValue}): `;
+    for (let attempt = 0; attempt < MAX_INTERACTIVE_PROMPT_ATTEMPTS; attempt++) {
+        const raw = (await io.prompt?.(question))?.trim().toLowerCase() ?? "";
+        const answer = normalizeStreamChoice(raw || defaultValue, choices);
+        if (answer)
+            return answer;
+        writeStreamError(io, `Invalid ${label}: expected one of: ${choices.join(", ")}`);
+    }
+    return null;
+}
+function normalizeStreamChoice(value, choices) {
+    const aliases = {
+        y: "yes",
+        n: "no",
+        stdout: "terminal",
+        tee: "both",
+    };
+    const normalized = aliases[value] ?? value;
+    return choices.includes(normalized) ? normalized : null;
+}
+async function pathExists(value) {
+    try {
+        await access(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateStreamArgs(args, schema) {
+    for (const [key, zodType] of Object.entries(schema)) {
+        if (args[key] === undefined)
+            continue;
+        const error = validateToolArgAnswer(key, zodType, args[key]);
+        if (error)
+            return { key, error };
+    }
+    return null;
+}
+function collectInvalidStreamArgs(args, schema, valuelessArgs) {
+    const valueless = new Set(valuelessArgs);
+    const errors = [];
+    for (const [key, zodType] of Object.entries(schema)) {
+        if (args[key] === undefined)
+            continue;
+        if (valueless.has(key) && getZodTypeName(zodType) !== "boolean") {
+            errors.push({ key, error: "value is required" });
+            continue;
+        }
+        const error = validateToolArgAnswer(key, zodType, args[key]);
+        if (error)
+            errors.push({ key, error });
+    }
+    return errors;
+}
+function validateStreamOutputDependencies(args, schema) {
+    if (hasArgValue(args.output_file))
+        return null;
+    const coerced = coerceArgs(args, schema);
+    if (coerced.append === true)
+        return "--append requires --output_file.";
+    if (coerced.tee === true)
+        return "--tee requires --output_file.";
+    return null;
+}
+function writeStreamError(io, message) {
+    (io.progress ?? io.write)(message);
+}
+function closestStreamOption(input, options) {
+    const boundedInput = input.slice(0, 64);
+    let closest;
+    for (const option of options) {
+        const distance = editDistance(boundedInput, option);
+        if (!closest || distance < closest.distance)
+            closest = { option, distance };
+    }
+    if (!closest || closest.distance > Math.max(2, Math.floor(boundedInput.length / 3)))
+        return null;
+    return closest.option;
+}
+function editDistance(left, right) {
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let leftIndex = 1; leftIndex <= left.length; leftIndex++) {
+        const current = [leftIndex];
+        for (let rightIndex = 1; rightIndex <= right.length; rightIndex++) {
+            current[rightIndex] = Math.min(current[rightIndex - 1] + 1, previous[rightIndex] + 1, previous[rightIndex - 1] + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[right.length];
+}
+function pickStreamInput(values, schema) {
+    const known = new Set(Object.keys(schema));
+    return Object.fromEntries(Object.entries(values).filter(([key]) => known.has(key)));
+}
+function shouldSkipLiveStreamPrompt(key, type) {
+    if (type !== "quote" && type !== "quotes")
+        return false;
+    return [
+        "bar_type",
+        "bar_interval",
+        "dp",
+        "currency",
+        "unit",
+        "split",
+        "dadj",
+        "badj",
+        "settlement",
+    ].includes(key);
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function runUpdateCommand(io) {
     const runCommand = io.runCommand ?? defaultRunCommand;
     const status = await getCachedVersionStatus(io);
@@ -767,11 +1138,22 @@ function interactiveToolOptions() {
             name: RENDER_CHART_COMMAND,
             description: "Render Chart.js configs as PNG images",
         },
+        {
+            name: STREAM_LIVE_COMMAND,
+            description: "Stream real-time market data as NDJSON",
+        },
+        {
+            name: STREAM_NEWSFEED_COMMAND,
+            description: "Stream financial news as NDJSON",
+        },
     ];
 }
 function isHistoryDownloadCommand(toolName) {
     return toolName === DOWNLOAD_HISTORY_COMMAND || toolName === GET_SYMBOL_HISTORY_COMMAND;
 }
+function isStreamCommand(toolName) {
+    return toolName === STREAM_LIVE_COMMAND || toolName === STREAM_NEWSFEED_COMMAND;
+}
 function buildInteractiveToolList(options) {
     return [
         "Choose a tool:",
@@ -1596,6 +1978,21 @@ function selectToolWithKeyboard(options) {
 export function main() {
     const rl = createInterface({ input, output });
     const interactive = process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true";
+    const streamAbort = new AbortController();
+    let streamRunning = false;
+    let signalExitCode;
+    const handleSignal = (exitCode) => {
+        signalExitCode = exitCode;
+        streamAbort.abort();
+        if (!streamRunning) {
+            process.exitCode = exitCode;
+            rl.close();
+        }
+    };
+    const handleSigint = () => handleSignal(130);
+    const handleSigterm = () => handleSignal(143);
+    process.once("SIGINT", handleSigint);
+    process.once("SIGTERM", handleSigterm);
     runCli(process.argv.slice(2), {
         write: (s) => process.stdout.write(`${s}\n`),
         progress: (s) => process.stderr.write(`${s}\n`),
@@ -1603,7 +2000,29 @@ export function main() {
         prompt: (question) => rl.question(question),
         selectTool: canUseKeyboardToolSelection() ? selectToolWithKeyboard : undefined,
         isInteractive: interactive,
-        exit: (code) => process.exit(code),
-    }).finally(() => rl.close());
+        streamSignal: streamAbort.signal,
+        getStreamSignalExitCode: () => signalExitCode,
+        runStream: async (options) => {
+            streamRunning = true;
+            try {
+                return await runWebSocketStream(options);
+            }
+            finally {
+                streamRunning = false;
+            }
+        },
+        exit: (code) => {
+            process.exitCode = code;
+        },
+    })
+        .catch((error) => {
+        process.stderr.write(`Error: ${errorMessage(error)}\n`);
+        process.exitCode = 1;
+    })
+        .finally(() => {
+        process.removeListener("SIGINT", handleSigint);
+        process.removeListener("SIGTERM", handleSigterm);
+        rl.close();
+    });
 }
 //# sourceMappingURL=cli.js.map