@oomol-lab/open-connector 1.6.3 → 1.6.5

package/src/providers/zyhub/executors.js

@@ -0,0 +1,240 @@
+import { looseArray, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { readBoundedResponseBytes } from "../../core/request.js";
+import { defaultProviderJsonMaxResponseBytes, defineApiKeyProviderExecutors, ProviderRequestError, providerUserAgent, readProviderTextBody, runProviderRequest, } from "../provider-runtime.js";
+const service = "zyhub";
+const baseUrl = "https://mcp.finance.sina.com.cn/api-call/";
+const operations = {
+    search_symbols: {
+        code: "globalStockSearchSymbols",
+        query: (i) => ({ type: i.marketTypes, key: i.query, format: "text", num: 4 }),
+    },
+    get_stock_quote: { code: "globalStockQuoteRealtime", query: (i) => pick(i, { market: "market", symbol: "symbol" }) },
+    get_daily_kline: {
+        code: "globalStockKlineDaily",
+        query: (i) => ({
+            market: i.market,
+            symbol: i.symbol,
+            fq_type: i.adjustment,
+            compare: i.comparison,
+            in_date: i.date,
+            num: i.limit,
+        }),
+    },
+    get_company_profile: { code: "cnCompanyBasicInfo", query: symbol },
+    get_forex_quote: { code: "forexQuoteLatest", query: symbol },
+    search_news: { code: "newsSearch", query: (i) => ({ keyword: join(i.keywords), page: i.page, num: i.pageSize }) },
+    get_intraday_kline: {
+        code: "cnStockKLine",
+        query: (i) => ({ symbol: i.symbol, scale: i.intervalMinutes, datalen: i.limit }),
+    },
+    list_financial_report_dates: { code: "cnFinanceReportDateList", query: (i) => ({ paperCode: i.symbol }) },
+    get_financial_report: {
+        code: "cnFinanceReportsFull",
+        query: (i) => ({
+            paperCode: i.symbol,
+            source: map(i.reportType, {
+                income_statement: "lrb",
+                balance_sheet: "fzb",
+                cash_flow: "llb",
+                key_indicators: "gjzb",
+                special_indicators: "zxzb",
+            }),
+            rDate: i.reportDate,
+        }),
+    },
+    get_revenue_composition: {
+        code: "cnFinanceRevenueComposition",
+        query: (i) => ({ paperCode: i.symbol, frDate: i.reportDate }),
+    },
+    get_valuation_history: {
+        code: "cnStockValuationDetail",
+        query: (i) => ({
+            symbol: i.symbol,
+            rank: map(i.period, { "1y": "y1", "3y": "y3", "5y": "y5", "10y": "y10", all: "all" }),
+            type: map(i.metric, { pe_ttm: "syl", pb: "sjl", pcf: "sxl", dividend_yield: "gxl", market_cap: "zsz" }),
+        }),
+    },
+    get_major_events: {
+        code: "globalStockMajorEvents",
+        query: (i) => ({ market: map(i.market, { cn: "0", hk: "1", us: "2" }), symbols: i.symbol, pageSize: i.limit }),
+    },
+    get_margin_trading: { code: "cnStockTradingMarginList", query: pageSymbol },
+    get_block_trades: { code: "cnTradingBlockList", query: pageSymbol },
+    list_stock_connect_holdings: {
+        code: "cnStockConnectHoldings",
+        query: (i) => ({ type: i.channel, sort: i.sortBy, asc: direction(i.sortDirection), page: i.page, num: i.pageSize }),
+    },
+    get_stock_industry: { code: "swSymbolList", query: symbol },
+    list_sector_rankings: {
+        code: "cnVirtualSectorRanking",
+        query: (i) => ({
+            index_type: map(i.sectorType, {
+                all: "",
+                shenwan_level_1: "hy1",
+                shenwan_level_2: "hy",
+                shenwan_level_3: "hy3",
+                concept: "gn",
+                region: "dy",
+            }),
+            sort: i.sortBy,
+            asc: direction(i.sortDirection),
+            page: i.page,
+            num: i.pageSize,
+        }),
+    },
+    get_sector_constituents: {
+        code: "cnSectorComponentsRanking",
+        query: (i) => ({
+            node: i.sectorSymbol,
+            ret: join(i.fields),
+            sort: i.sortBy,
+            asc: direction(i.sortDirection),
+            page: i.page,
+            num: i.pageSize,
+            hnew: flag(i.includeNewStocks),
+            hcnew: flag(i.includeRecentStocks),
+        }),
+    },
+    list_strong_sectors: {
+        code: "cnMarketStrongSectors",
+        query: (i) => ({
+            type: map(i.boardGroup, { all: "all", growth: "ck", other: "other" }),
+            bk: map(i.sectorType, { concept: "gn", industry: "hy", region: "dy" }),
+            isNotSt: flag(i.excludeSt),
+        }),
+    },
+    list_limit_up_stocks: { code: "cnMarketLimitUpPool" },
+    list_consecutive_limit_up_stocks: { code: "cnStockLianBC" },
+    list_hot_stocks: {
+        code: "globalStockHotBoard",
+        query: (i) => ({ type: map(i.period, { day: "d", hour: "h" }), market: i.market, page: i.page, num: i.pageSize }),
+    },
+    get_batch_forex_quotes: {
+        code: "forexQuotesBatch",
+        query: (i) => ({ from: i.baseCurrency, to: join(i.targetCurrencies) }),
+    },
+    get_futures_quote: {
+        code: "future_quotes",
+        query: (i) => ({ market: map(i.market, { domestic: "gn", global: "global", financial: "cff" }), symbol: i.symbol }),
+    },
+    search_stock_news: {
+        code: "stockNewsSearch",
+        query: (i) => ({ market: i.market, symbol: i.symbol, page: i.page, num: i.pageSize }),
+    },
+    search_flash_news: {
+        code: "qNewsSearch",
+        query: (i) => ({ keyword: join(i.keywords), page: i.page, num: i.pageSize }),
+    },
+    list_flash_news: {
+        code: "newsFlashList",
+        query: (i) => ({
+            id: i.documentId,
+            type: map(i.direction, { after: "0", before: "1" }),
+            page: i.page,
+            num: i.pageSize,
+        }),
+    },
+    get_news_article: { code: "newsArticleDetail", query: (i) => ({ docid: i.documentId }) },
+    get_fund_profile: { code: "fund_info", query: symbol },
+    get_fund_net_values: { code: "fund_networth", query: symbol },
+    get_fund_returns: { code: "fund_cum_return", query: symbol },
+    get_fund_metrics: { code: "fund_core_metrics", query: symbol },
+    get_fund_stock_holdings: { code: "fund_heavy_stock", query: pageSymbol },
+    get_fund_industry_allocation: { code: "fund_industry_alloc", query: symbol },
+    get_fund_asset_allocation: { code: "fund_asset_alloc", query: symbol },
+    get_fund_manager: { code: "fund_manager_detail", query: (i) => ({ pscode: i.managerCode }) },
+};
+const handlers = Object.fromEntries(Object.entries(operations).map(([name, operation]) => [
+    name,
+    (input, context) => execute(operation, input, context),
+]));
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, context) {
+        await request("cnMarketUpdownDistribution", {}, input.apiKey, context.fetcher, context.signal, true);
+        return {
+            profile: { accountId: "zyhub-api-key", displayName: "Sina Finance ZYHub API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "cnMarketUpdownDistribution" },
+        };
+    },
+};
+async function execute(operation, input, context) {
+    return {
+        response: await request(operation.code, operation.query?.(input) ?? {}, context.apiKey, context.fetcher, context.signal, false),
+    };
+}
+async function request(code, query, apiKey, fetcher, parentSignal, validating) {
+    return runProviderRequest({ signal: parentSignal, label: "Sina Finance ZYHub" }, async (signal) => {
+        const url = new URL(code, baseUrl);
+        for (const [key, value] of Object.entries(query))
+            if (value != null)
+                url.searchParams.set(key, String(value));
+        const response = await fetcher(url, {
+            headers: { accept: "application/json", "user-agent": providerUserAgent, "X-Auth-Token": apiKey },
+            signal,
+        });
+        const text = code === "globalStockSearchSymbols" && response.ok
+            ? new TextDecoder("gb18030").decode(await readBoundedResponseBytes(response, {
+                maxBytes: defaultProviderJsonMaxResponseBytes,
+                fieldName: "ZYHub response",
+                createError: (message) => new ProviderRequestError(413, message),
+            }))
+            : await readProviderTextBody(response, "ZYHub response");
+        const payload = parse(text);
+        if (!response.ok) {
+            const message = errorMessage(payload) ?? `ZYHub request failed with status ${response.status}`;
+            if (response.status === 429)
+                throw new ProviderRequestError(429, message, payload);
+            if (validating && response.status === 401)
+                throw new ProviderRequestError(400, message, payload);
+            throw new ProviderRequestError(response.status, message, payload);
+        }
+        return payload;
+    });
+}
+function parse(text) {
+    if (!text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function errorMessage(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    const body = optionalRecord(value);
+    return optionalString(body?.message) ?? optionalString(body?.msg) ?? optionalString(body?.error);
+}
+function map(value, values) {
+    const key = optionalString(value);
+    return key == null ? undefined : values[key];
+}
+function direction(value) {
+    return map(value, { desc: "0", asc: "1" });
+}
+function flag(value) {
+    const result = optionalBoolean(value);
+    return result == null ? undefined : result ? 1 : 0;
+}
+function join(value) {
+    return value == null ? undefined : looseArray(value).join(",");
+}
+function symbol(input) {
+    return { symbol: optionalString(input.symbol) };
+}
+function pageSymbol(input) {
+    return {
+        symbol: optionalString(input.symbol),
+        page: optionalInteger(input.page),
+        num: optionalInteger(input.pageSize),
+    };
+}
+function pick(input, fields) {
+    return Object.fromEntries(Object.entries(fields).map(([to, from]) => [to, input[from]]));
+}

package/src/server/files/transit-files.d.ts

@@ -1,4 +1,4 @@
-import type { TransitFileRead, TransitFileUpload } from "../../core/types.ts";
+import type { TransitFileRead, TransitFileStream, TransitFileUpload } from "../../core/types.ts";
 import type { IStagedTransitFileService, StagedTransitFile } from "./transit-file-store.ts";
 export interface TransitFileOptions {
     rootDir: string;
@@ -13,6 +13,7 @@ export declare class TransitFileService implements IStagedTransitFileService {
     readonly maxBytes: number;
     constructor(options: TransitFileOptions);
     create(file: File): Promise<TransitFileUpload>;
+    createFromStream(file: TransitFileStream): Promise<TransitFileUpload>;
     createFromPath(file: StagedTransitFile): Promise<TransitFileUpload>;
     read(fileId: string): Promise<TransitFileRead>;
     response(fileId: string): Promise<Response>;
@@ -21,5 +22,5 @@ export declare class TransitFileService implements IStagedTransitFileService {
     /** Resolve a live, unexpired file on disk together with its side-car metadata, or report it as missing. */
     private locate;
     private readMetadata;
-    private writeFile;
+    private writeStream;
 }

package/src/server/files/transit-files.js

@@ -1,9 +1,8 @@
-import { once } from "node:events";
 import { createReadStream, createWriteStream } from "node:fs";
 import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { Readable } from "node:stream";
-import { finished } from "node:stream/promises";
+import { pipeline } from "node:stream/promises";
 import { assertFileSize, assertSafeFileId, contentTypeFromFileId, isSafeFileId, normalizeDescriptor, randomHex, safeExtension, TransitFileError, transitFileRead, transitFileResponse, uploadResult, } from "./transit-file-store.js";
 export class TransitFileService {
     rootDir;
@@ -18,19 +17,33 @@ export class TransitFileService {
     }
     async create(file) {
         assertFileSize(file.size, this.maxBytes);
-        await this.cleanupExpired();
-        await mkdir(this.rootDir, { recursive: true });
+        return this.createFromStream({ body: file.stream(), name: file.name, mimeType: file.type });
+    }
+    async createFromStream(file) {
         const fileId = `${randomHex(16)}${safeExtension(file.name)}`;
         const path = join(this.rootDir, fileId);
         const tempPath = `${path}.tmp`;
-        const sizeBytes = await this.writeFile(file, tempPath);
-        await rename(tempPath, path);
         const metadata = normalizeDescriptor({
             name: file.name || fileId,
-            mimeType: file.type || contentTypeFromFileId(fileId),
+            mimeType: file.mimeType || contentTypeFromFileId(fileId),
         });
-        await writeFile(metadataPath(path), JSON.stringify(metadata), { flag: "wx" });
-        return uploadResult(this.publicOrigin, fileId, { ...metadata, sizeBytes });
+        try {
+            file.signal?.throwIfAborted();
+            await this.cleanupExpired();
+            const sizeBytes = await this.writeStream(file, tempPath);
+            file.signal?.throwIfAborted();
+            await writeFile(metadataPath(path), JSON.stringify(metadata), { flag: "wx", signal: file.signal });
+            await rename(tempPath, path);
+            file.signal?.throwIfAborted();
+            return uploadResult(this.publicOrigin, fileId, { ...metadata, sizeBytes });
+        }
+        catch (error) {
+            if (!file.body.locked) {
+                await file.body.cancel(error).catch(() => undefined);
+            }
+            await Promise.all([tempPath, path, metadataPath(path)].map((filePath) => unlink(filePath).catch(() => undefined)));
+            throw error;
+        }
     }
     async createFromPath(file) {
         assertFileSize(file.sizeBytes, this.maxBytes);
@@ -114,34 +127,17 @@ export class TransitFileService {
             return fallback;
         }
     }
-    async writeFile(file, tempPath) {
-        const writer = createWriteStream(tempPath, { flags: "wx" });
-        const reader = file.stream().getReader();
+    async writeStream(file, tempPath) {
         let sizeBytes = 0;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                sizeBytes += value.byteLength;
-                assertFileSize(sizeBytes, this.maxBytes);
-                if (!writer.write(value)) {
-                    await once(writer, "drain");
-                }
+        const maxBytes = this.maxBytes;
+        await pipeline(Readable.fromWeb(file.body), async function* (source) {
+            for await (const chunk of source) {
+                sizeBytes += chunk.byteLength;
+                assertFileSize(sizeBytes, maxBytes);
+                yield chunk;
             }
-            writer.end();
-            await finished(writer);
-            return sizeBytes;
-        }
-        catch (error) {
-            writer.destroy();
-            await unlink(tempPath).catch(() => undefined);
-            throw error;
-        }
-        finally {
-            reader.releaseLock();
-        }
+        }, createWriteStream(tempPath, { flags: "wx" }), { signal: file.signal });
+        return sizeBytes;
     }
 }
 function isManagedFileName(fileName) {