tickflow-assist 0.2.18 → 0.3.1

package/dist/services/jin10-mcp-service.js

@@ -0,0 +1,242 @@
+export class Jin10McpService {
+    serverUrl;
+    apiToken;
+    requestId = 1;
+    initialized = false;
+    sessionId = null;
+    constructor(serverUrl, apiToken) {
+        this.serverUrl = serverUrl;
+        this.apiToken = apiToken;
+    }
+    isConfigured() {
+        return this.getConfigurationError() == null;
+    }
+    getConfigurationError() {
+        if (!this.serverUrl.trim()) {
+            return "Jin10 MCP 未配置接口地址，请设置 jin10McpUrl";
+        }
+        if (!this.apiToken.trim()) {
+            return "Jin10 MCP 未配置 API Token，请设置 jin10ApiToken";
+        }
+        return null;
+    }
+    async listFlash(cursor) {
+        const payload = await this.callTool("list_flash", cursor ? { cursor } : {});
+        return normalizeFlashPage(payload);
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        await this.request("initialize", {
+            protocolVersion: "2025-11-25",
+            capabilities: {},
+            clientInfo: {
+                name: "mcp-client",
+                version: "1.0.0",
+            },
+        });
+        await this.notify("notifications/initialized");
+        try {
+            await this.request("tools/list", {});
+            await this.request("resources/list", {});
+        }
+        catch {
+            // Tool listing is a best-effort handshake step.
+        }
+        this.initialized = true;
+    }
+    async callTool(name, args) {
+        await this.initialize();
+        const result = await this.request("tools/call", {
+            name,
+            arguments: args,
+        });
+        if (!result) {
+            throw new Error(`jin10 tool ${name} returned empty result`);
+        }
+        if (result.isError) {
+            throw new Error(`jin10 tool ${name} returned MCP error`);
+        }
+        if (result.structuredContent !== undefined) {
+            return result.structuredContent;
+        }
+        const structured = result.content?.find((item) => item.structuredContent !== undefined)?.structuredContent;
+        if (structured !== undefined) {
+            return structured;
+        }
+        const text = result.content?.find((item) => typeof item.text === "string")?.text;
+        if (typeof text === "string" && text.trim()) {
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        }
+        return result;
+    }
+    async request(method, params) {
+        const configError = this.getConfigurationError();
+        if (configError) {
+            throw new Error(configError);
+        }
+        const payload = {
+            jsonrpc: "2.0",
+            id: this.requestId++,
+            method,
+            params,
+        };
+        const response = await fetch(this.serverUrl, {
+            method: "POST",
+            headers: this.buildHeaders(),
+            body: JSON.stringify(payload),
+        });
+        const sessionId = response.headers.get("mcp-session-id");
+        if (sessionId) {
+            this.sessionId = sessionId;
+        }
+        const rawText = await response.text();
+        if (!response.ok) {
+            throw new Error(`jin10 MCP request failed: ${response.status} ${response.statusText} ${rawText}`);
+        }
+        const parsed = parseJsonRpcResponse(rawText, payload.id);
+        if (parsed.error) {
+            throw new Error(`jin10 MCP error (${parsed.error.code ?? "unknown"}): ${parsed.error.message ?? "unknown"}`);
+        }
+        return parsed.result;
+    }
+    async notify(method) {
+        const configError = this.getConfigurationError();
+        if (configError) {
+            throw new Error(configError);
+        }
+        const payload = {
+            jsonrpc: "2.0",
+            method,
+        };
+        const response = await fetch(this.serverUrl, {
+            method: "POST",
+            headers: this.buildHeaders(),
+            body: JSON.stringify(payload),
+        });
+        const sessionId = response.headers.get("mcp-session-id");
+        if (sessionId) {
+            this.sessionId = sessionId;
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`jin10 MCP notification failed: ${response.status} ${response.statusText} ${text}`);
+        }
+    }
+    buildHeaders() {
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiToken}`,
+        };
+        if (this.sessionId) {
+            headers["Mcp-Session-Id"] = this.sessionId;
+        }
+        return headers;
+    }
+}
+export function parseJsonRpcResponse(rawText, expectedId) {
+    const trimmed = rawText.trim();
+    if (!trimmed) {
+        throw new Error("jin10 MCP returned empty body");
+    }
+    if (!looksLikeSsePayload(trimmed)) {
+        return JSON.parse(trimmed);
+    }
+    const candidates = parseSseJsonRpcResponses(trimmed);
+    if (candidates.length === 0) {
+        throw new Error(`jin10 MCP SSE payload missing JSON-RPC data: ${truncate(trimmed, 160)}`);
+    }
+    if (expectedId !== undefined) {
+        const matched = candidates.find((entry) => entry.id === expectedId);
+        if (matched) {
+            return matched;
+        }
+    }
+    const withResult = candidates.find((entry) => entry.result !== undefined || entry.error !== undefined);
+    if (withResult) {
+        return withResult;
+    }
+    return candidates[candidates.length - 1];
+}
+function parseSseJsonRpcResponses(rawText) {
+    const events = rawText
+        .split(/\r?\n\r?\n/)
+        .map((chunk) => chunk.trim())
+        .filter(Boolean);
+    const responses = [];
+    for (const eventText of events) {
+        const payload = extractSseData(eventText);
+        if (!payload || payload === "[DONE]") {
+            continue;
+        }
+        try {
+            responses.push(JSON.parse(payload));
+        }
+        catch {
+            continue;
+        }
+    }
+    return responses;
+}
+function extractSseData(eventText) {
+    const dataLines = eventText
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.replace(/^data:\s?/, ""));
+    return dataLines.join("\n").trim();
+}
+function looksLikeSsePayload(value) {
+    return value.startsWith("data:")
+        || value.startsWith("event:")
+        || value.startsWith(":")
+        || /\r?\ndata:/.test(value)
+        || /\r?\nevent:/.test(value);
+}
+function truncate(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function normalizeFlashPage(value) {
+    const root = isRecord(value) ? value : {};
+    const data = isRecord(root.data) ? root.data : {};
+    const items = Array.isArray(data.items) ? data.items : [];
+    return {
+        hasMore: data.has_more === true,
+        items: items
+            .map((item) => normalizeFlashItem(item))
+            .filter((item) => item != null),
+        nextCursor: normalizeNullableString(data.next_cursor),
+    };
+}
+function normalizeFlashItem(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const content = String(value.content ?? "").trim();
+    const time = String(value.time ?? "").trim();
+    const url = String(value.url ?? "").trim();
+    if (!content || !time || !url) {
+        return null;
+    }
+    return {
+        content,
+        time,
+        url,
+        raw: value,
+    };
+}
+function normalizeNullableString(value) {
+    const text = typeof value === "string" ? value.trim() : "";
+    return text || null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/storage/repositories/jin10-flash-delivery-repo.d.ts

@@ -0,0 +1,10 @@
+import type { Jin10FlashDeliveryEntry } from "../../types/jin10.js";
+import { Database } from "../db.js";
+export declare class Jin10FlashDeliveryRepository {
+    private readonly db;
+    constructor(db: Database);
+    append(entry: Jin10FlashDeliveryEntry): Promise<void>;
+    hasDelivered(flashKey: string): Promise<boolean>;
+    countSinceDeliveredAt(deliveredAt: string): Promise<number>;
+    pruneOlderThanDeliveredAt(deliveredAt: string): Promise<void>;
+}

package/dist/storage/repositories/jin10-flash-delivery-repo.js

@@ -0,0 +1,57 @@
+import { jin10FlashDeliverySchema } from "../schemas.js";
+const JIN10_FLASH_DELIVERY_TABLE = "jin10_flash_delivery";
+export class Jin10FlashDeliveryRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = toDeliveryRow(entry);
+        if (!(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            await this.db.createTable(JIN10_FLASH_DELIVERY_TABLE, [row], jin10FlashDeliverySchema);
+            return;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        await table.add([row]);
+    }
+    async hasDelivered(flashKey) {
+        if (!flashKey || !(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            return false;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        const rows = (await table
+            .query()
+            .where(`flash_key = '${escapeSqlString(flashKey)}'`)
+            .toArray());
+        return rows.length > 0;
+    }
+    async countSinceDeliveredAt(deliveredAt) {
+        if (!(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            return 0;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        return table.countRows(`delivered_at >= '${escapeSqlString(deliveredAt)}'`);
+    }
+    async pruneOlderThanDeliveredAt(deliveredAt) {
+        if (!(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            return;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        await table.delete(`delivered_at < '${escapeSqlString(deliveredAt)}'`);
+    }
+}
+function toDeliveryRow(entry) {
+    return {
+        flash_key: entry.flash_key,
+        published_at: entry.published_at,
+        symbols_json: JSON.stringify(entry.symbols),
+        headline: entry.headline,
+        reason: entry.reason,
+        importance: entry.importance,
+        message: entry.message,
+        delivered_at: entry.delivered_at,
+    };
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/jin10-flash-repo.d.ts

@@ -0,0 +1,15 @@
+import type { Jin10FlashRecord } from "../../types/jin10.js";
+import { Database } from "../db.js";
+export declare class Jin10FlashRepository {
+    private readonly db;
+    constructor(db: Database);
+    saveAll(entries: Jin10FlashRecord[]): Promise<{
+        added: number;
+        skipped: number;
+        addedKeys: string[];
+    }>;
+    getLatest(): Promise<Jin10FlashRecord | null>;
+    countSincePublishedTs(publishedTs: number): Promise<number>;
+    pruneOlderThanPublishedTs(publishedTs: number): Promise<void>;
+    private listExistingKeys;
+}

package/dist/storage/repositories/jin10-flash-repo.js

@@ -0,0 +1,126 @@
+import { jin10FlashSchema } from "../schemas.js";
+const JIN10_FLASH_TABLE = "jin10_flash";
+export class Jin10FlashRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async saveAll(entries) {
+        const uniqueEntries = dedupeEntries(entries);
+        if (uniqueEntries.length === 0) {
+            return { added: 0, skipped: 0, addedKeys: [] };
+        }
+        const rows = uniqueEntries.map((entry) => toFlashRow(entry));
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            await this.db.createTable(JIN10_FLASH_TABLE, rows, jin10FlashSchema);
+            return {
+                added: rows.length,
+                skipped: 0,
+                addedKeys: uniqueEntries.map((entry) => entry.flash_key),
+            };
+        }
+        const existingKeys = await this.listExistingKeys(uniqueEntries.map((entry) => entry.flash_key));
+        const newEntries = uniqueEntries.filter((entry) => !existingKeys.has(entry.flash_key));
+        const newRows = newEntries.map((entry) => toFlashRow(entry));
+        if (newRows.length === 0) {
+            return {
+                added: 0,
+                skipped: rows.length,
+                addedKeys: [],
+            };
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        await table.add(newRows);
+        return {
+            added: newRows.length,
+            skipped: rows.length - newRows.length,
+            addedKeys: newEntries.map((entry) => entry.flash_key),
+        };
+    }
+    async getLatest() {
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return null;
+        }
+        const rows = await this.db.tableToArray(JIN10_FLASH_TABLE);
+        if (rows.length === 0) {
+            return null;
+        }
+        return fromFlashRow(rows[rows.length - 1]);
+    }
+    async countSincePublishedTs(publishedTs) {
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return 0;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        return table.countRows(`published_ts >= ${Math.trunc(publishedTs)}`);
+    }
+    async pruneOlderThanPublishedTs(publishedTs) {
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        await table.delete(`published_ts < ${Math.trunc(publishedTs)}`);
+    }
+    async listExistingKeys(keys) {
+        if (keys.length === 0 || !(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return new Set();
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        const rows = (await table
+            .query()
+            .where(`flash_key IN (${keys.map((key) => `'${escapeSqlString(key)}'`).join(", ")})`)
+            .toArray());
+        return new Set(rows.map((row) => String(row.flash_key ?? "")));
+    }
+}
+function toFlashRow(entry) {
+    return {
+        flash_key: entry.flash_key,
+        published_at: entry.published_at,
+        published_ts: Math.trunc(entry.published_ts),
+        content: entry.content,
+        url: entry.url,
+        ingested_at: entry.ingested_at,
+        raw_json: JSON.stringify(entry.raw),
+    };
+}
+function fromFlashRow(row) {
+    return {
+        flash_key: String(row.flash_key ?? ""),
+        published_at: String(row.published_at ?? ""),
+        published_ts: Number(row.published_ts ?? 0),
+        content: String(row.content ?? ""),
+        url: String(row.url ?? ""),
+        ingested_at: String(row.ingested_at ?? ""),
+        raw: parseJsonObject(row.raw_json),
+    };
+}
+function dedupeEntries(entries) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries) {
+        if (!entry.flash_key || seen.has(entry.flash_key)) {
+            continue;
+        }
+        seen.add(entry.flash_key);
+        result.push(entry);
+    }
+    return result;
+}
+function parseJsonObject(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/schemas.d.ts

@@ -11,3 +11,5 @@ export declare const financialAnalysisSchema: Schema<any>;
 export declare const newsAnalysisSchema: Schema<any>;
 export declare const compositeAnalysisSchema: Schema<any>;
 export declare const alertLogSchema: Schema<any>;
+export declare const jin10FlashSchema: Schema<any>;
+export declare const jin10FlashDeliverySchema: Schema<any>;

package/dist/storage/schemas.js

@@ -175,3 +175,22 @@ export const alertLogSchema = new Schema([
     new Field("message", new Utf8(), false),
     new Field("triggered_at", new Utf8(), false),
 ]);
+export const jin10FlashSchema = new Schema([
+    new Field("flash_key", new Utf8(), false),
+    new Field("published_at", new Utf8(), false),
+    new Field("published_ts", new Int64(), false),
+    new Field("content", new Utf8(), false),
+    new Field("url", new Utf8(), false),
+    new Field("ingested_at", new Utf8(), false),
+    new Field("raw_json", new Utf8(), false),
+]);
+export const jin10FlashDeliverySchema = new Schema([
+    new Field("flash_key", new Utf8(), false),
+    new Field("published_at", new Utf8(), false),
+    new Field("symbols_json", new Utf8(), false),
+    new Field("headline", new Utf8(), false),
+    new Field("reason", new Utf8(), false),
+    new Field("importance", new Utf8(), false),
+    new Field("message", new Utf8(), false),
+    new Field("delivered_at", new Utf8(), false),
+]);

package/dist/tools/flash-monitor-status.tool.d.ts

@@ -0,0 +1,6 @@
+import { Jin10FlashMonitorService } from "../services/jin10-flash-monitor-service.js";
+export declare function flashMonitorStatusTool(flashMonitorService: Jin10FlashMonitorService): {
+    name: string;
+    description: string;
+    run(): Promise<string>;
+};

package/dist/tools/flash-monitor-status.tool.js

@@ -0,0 +1,9 @@
+export function flashMonitorStatusTool(flashMonitorService) {
+    return {
+        name: "flash_monitor_status",
+        description: "Show Jin10 flash monitor state, recent poll summary, and storage counters.",
+        async run() {
+            return flashMonitorService.getStatusReport();
+        },
+    };
+}

package/dist/types/flash-monitor.d.ts

@@ -0,0 +1,17 @@
+export interface FlashMonitorState {
+    initialized: boolean;
+    lastSeenKey: string | null;
+    lastSeenPublishedAt: string | null;
+    lastSeenUrl: string | null;
+    backfillCursor: string | null;
+    runtimeHost: "plugin_service" | "fallback_process" | null;
+    runtimeObservedAt: string | null;
+    lastHeartbeatAt: string | null;
+    lastPollAt: string | null;
+    lastPollStored: number;
+    lastPollCandidates: number;
+    lastPollAlerts: number;
+    lastPrunedAt: string | null;
+    lastLoopError: string | null;
+    lastLoopErrorAt: string | null;
+}

package/dist/types/flash-monitor.js

@@ -0,0 +1 @@
+export {};

package/dist/types/jin10.d.ts

@@ -0,0 +1,30 @@
+export interface Jin10FlashItem {
+    content: string;
+    time: string;
+    url: string;
+    raw: Record<string, unknown>;
+}
+export interface Jin10FlashPage {
+    hasMore: boolean;
+    items: Jin10FlashItem[];
+    nextCursor: string | null;
+}
+export interface Jin10FlashRecord {
+    flash_key: string;
+    published_at: string;
+    published_ts: number;
+    content: string;
+    url: string;
+    ingested_at: string;
+    raw: Record<string, unknown>;
+}
+export interface Jin10FlashDeliveryEntry {
+    flash_key: string;
+    published_at: string;
+    symbols: string[];
+    headline: string;
+    reason: string;
+    importance: "high" | "medium" | "low";
+    message: string;
+    delivered_at: string;
+}

package/dist/types/jin10.js

@@ -0,0 +1 @@
+export {};

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "tickflow-assist",
   "name": "TickFlow Assist",
-  "version": "0.2.18",
+  "version": "0.3.1",
   "description": "A-share watchlist analysis, monitoring, and alert delivery powered by TickFlow and OpenClaw.",
   "skills": [
     "skills"
@@ -36,6 +36,28 @@
         "default": "",
         "description": "Optional. Enables mx_search, mx_select_stock, and non-Expert financial fallback."
       },
+      "jin10McpUrl": {
+        "type": "string",
+        "default": "https://mcp.jin10.com/mcp",
+        "description": "Jin10 MCP server URL used for realtime flash monitoring."
+      },
+      "jin10ApiToken": {
+        "type": "string",
+        "default": "",
+        "description": "Optional. Enables 24/7 Jin10 realtime flash monitoring when configured."
+      },
+      "jin10FlashPollInterval": {
+        "type": "integer",
+        "minimum": 10,
+        "default": 300,
+        "description": "Jin10 flash polling interval in seconds."
+      },
+      "jin10FlashRetentionDays": {
+        "type": "integer",
+        "minimum": 1,
+        "default": 7,
+        "description": "How many days of raw Jin10 flash data to retain locally."
+      },
       "llmBaseUrl": {
         "type": "string",
         "default": "https://api.openai.com/v1",
@@ -125,6 +147,26 @@
       "help": "Optional. Enables mx_search, mx_select_stock, and lite financial fallback.",
       "sensitive": true
     },
+    "jin10McpUrl": {
+      "label": "Jin10 MCP URL",
+      "help": "Optional. MCP endpoint used by the 24/7 Jin10 flash monitor.",
+      "advanced": true
+    },
+    "jin10ApiToken": {
+      "label": "Jin10 API Token",
+      "help": "Optional. Enables Jin10 realtime flash monitoring.",
+      "sensitive": true
+    },
+    "jin10FlashPollInterval": {
+      "label": "Jin10 Poll Interval",
+      "help": "Polling interval in seconds for Jin10 flash monitoring.",
+      "advanced": true
+    },
+    "jin10FlashRetentionDays": {
+      "label": "Jin10 Retention Days",
+      "help": "How many days of Jin10 raw flash data to keep locally.",
+      "advanced": true
+    },
     "llmBaseUrl": {
       "label": "LLM Base URL",
       "help": "OpenAI-compatible analysis endpoint."