opencandle 0.11.1 → 0.13.0

package/dist/gui/server/local-session-coordinator.d.ts

@@ -0,0 +1,26 @@
+export type SessionActionType = "chat.prompt" | "tool.invoke" | "ask_user.answer" | "ask_user.cancel" | "run.cancel";
+export type SessionActionSource = "gui" | "tui" | "browser";
+export interface SessionActionEnvelope {
+    sessionId: string;
+    actionId: string;
+    actionType: SessionActionType;
+    payload: Record<string, unknown>;
+    source: SessionActionSource;
+}
+export type SessionActionResult<T = unknown> = {
+    ok: true;
+    duplicate: boolean;
+    result: T;
+} | {
+    ok: false;
+    code: "session_busy";
+    message: string;
+};
+export interface LocalSessionCoordinator {
+    runSessionAction<T>(action: SessionActionEnvelope, handler: (action: SessionActionEnvelope) => Promise<T>): Promise<SessionActionResult<T>>;
+}
+export interface LocalSessionCoordinatorOptions {
+    dedupeRetentionMs?: number;
+    now?: () => number;
+}
+export declare function createLocalSessionCoordinator(options?: LocalSessionCoordinatorOptions): LocalSessionCoordinator;

package/dist/gui/server/local-session-coordinator.js

@@ -0,0 +1,53 @@
+const DEFAULT_DEDUPE_RETENTION_MS = 10 * 60 * 1000;
+const BUSY_MESSAGE = "OpenCandle is still working in this session. Try again when it finishes.";
+export function createLocalSessionCoordinator(options = {}) {
+    const now = options.now ?? Date.now;
+    const dedupeRetentionMs = options.dedupeRetentionMs ?? DEFAULT_DEDUPE_RETENTION_MS;
+    const acceptedActions = new Map();
+    const activeActions = new Map();
+    const activeRunSessions = new Set();
+    async function runSessionAction(action, handler) {
+        pruneExpiredActions();
+        const actionKey = `${action.sessionId}:${action.actionId}`;
+        const accepted = acceptedActions.get(actionKey);
+        if (accepted)
+            return { ok: true, duplicate: true, result: accepted.result };
+        const active = activeActions.get(actionKey);
+        if (active)
+            return { ok: true, duplicate: true, result: (await active) };
+        if (isRunAdmissionAction(action) && activeRunSessions.has(action.sessionId)) {
+            return { ok: false, code: "session_busy", message: BUSY_MESSAGE };
+        }
+        if (isRunAdmissionAction(action))
+            activeRunSessions.add(action.sessionId);
+        const runAction = (async () => {
+            const result = await handler(action);
+            acceptedActions.set(actionKey, {
+                expiresAt: now() + dedupeRetentionMs,
+                result,
+            });
+            return result;
+        })();
+        activeActions.set(actionKey, runAction);
+        try {
+            const result = await runAction;
+            return { ok: true, duplicate: false, result };
+        }
+        finally {
+            activeActions.delete(actionKey);
+            if (isRunAdmissionAction(action))
+                activeRunSessions.delete(action.sessionId);
+        }
+    }
+    function pruneExpiredActions() {
+        const currentTime = now();
+        for (const [actionKey, accepted] of acceptedActions) {
+            if (accepted.expiresAt <= currentTime)
+                acceptedActions.delete(actionKey);
+        }
+    }
+    return { runSessionAction };
+}
+function isRunAdmissionAction(action) {
+    return action.actionType === "chat.prompt" || action.actionType === "tool.invoke";
+}

package/dist/gui/server/market-indices-api.d.ts

@@ -0,0 +1,21 @@
+import { type MarketSparklineSnapshot } from "./market-state-api.js";
+export declare const MARKET_INDEX_SYMBOLS: readonly ["^GSPC", "^IXIC", "^DJI", "BTC-USD"];
+export interface MarketIndexSnapshotEntry {
+    symbol: (typeof MARKET_INDEX_SYMBOLS)[number];
+    name?: string;
+    status: "ok" | "unavailable";
+    reason?: string;
+    price?: number;
+    change?: number;
+    changePercent?: number;
+    currency?: string | null;
+    marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+    dataAsOf?: string;
+    stale?: boolean;
+    sparkline?: MarketSparklineSnapshot;
+}
+export interface MarketIndicesSnapshot {
+    generatedAt: string;
+    indices: MarketIndexSnapshotEntry[];
+}
+export declare function buildMarketIndicesSnapshot(): Promise<MarketIndicesSnapshot>;

package/dist/gui/server/market-indices-api.js

@@ -0,0 +1,26 @@
+import { fetchQuoteSnapshot, fetchSparklineSnapshot, } from "./market-state-api.js";
+export const MARKET_INDEX_SYMBOLS = ["^GSPC", "^IXIC", "^DJI", "BTC-USD"];
+export async function buildMarketIndicesSnapshot() {
+    const indices = [];
+    for (const symbol of MARKET_INDEX_SYMBOLS) {
+        const quote = await fetchQuoteSnapshot(symbol);
+        if (quote.status === "unavailable") {
+            indices.push({ symbol, status: "unavailable", reason: quote.reason });
+            continue;
+        }
+        indices.push({
+            symbol,
+            name: quote.name,
+            status: "ok",
+            price: quote.price,
+            change: quote.change,
+            changePercent: quote.changePercent,
+            currency: quote.currency,
+            marketState: quote.marketState,
+            dataAsOf: quote.dataAsOf,
+            stale: quote.stale,
+            sparkline: await fetchSparklineSnapshot(symbol),
+        });
+    }
+    return { generatedAt: new Date().toISOString(), indices };
+}

package/dist/gui/server/market-indices-snapshot-store.d.ts

@@ -0,0 +1,12 @@
+import type { MarketIndicesSnapshot } from "./market-indices-api.js";
+export declare class MarketIndicesSnapshotStore {
+    private readonly build;
+    private readonly maxAgeMs;
+    private readonly now;
+    private snapshot;
+    private fetchedAtMs;
+    private inFlight;
+    constructor(build: () => Promise<MarketIndicesSnapshot>, maxAgeMs?: number, now?: () => number);
+    get(): Promise<MarketIndicesSnapshot>;
+    private refresh;
+}

package/dist/gui/server/market-indices-snapshot-store.js

@@ -0,0 +1,56 @@
+export class MarketIndicesSnapshotStore {
+    build;
+    maxAgeMs;
+    now;
+    snapshot = null;
+    fetchedAtMs = 0;
+    inFlight = null;
+    constructor(build, maxAgeMs = 60_000, now = Date.now) {
+        this.build = build;
+        this.maxAgeMs = maxAgeMs;
+        this.now = now;
+    }
+    async get() {
+        if (this.snapshot == null)
+            return this.refresh();
+        if (this.now() - this.fetchedAtMs >= this.maxAgeMs) {
+            this.refresh().catch(() => { });
+            return {
+                ...this.snapshot,
+                indices: this.snapshot.indices.map((entry) => ({ ...entry, stale: true })),
+            };
+        }
+        return this.snapshot;
+    }
+    refresh() {
+        if (this.inFlight)
+            return this.inFlight;
+        const inFlight = this.build()
+            .then((snapshot) => {
+            if (this.snapshot && snapshot.indices.some((entry) => entry.status === "unavailable")) {
+                const validRefreshCount = snapshot.indices.filter((entry) => entry.status === "ok").length;
+                if (validRefreshCount === 0)
+                    return this.snapshot;
+                const priorBySymbol = new Map(this.snapshot.indices.map((entry) => [entry.symbol, entry]));
+                snapshot = {
+                    ...snapshot,
+                    indices: snapshot.indices.map((entry) => {
+                        if (entry.status === "ok")
+                            return entry;
+                        const prior = priorBySymbol.get(entry.symbol);
+                        return prior?.status === "ok" ? { ...prior, stale: true } : entry;
+                    }),
+                };
+            }
+            this.snapshot = snapshot;
+            this.fetchedAtMs = this.now();
+            return snapshot;
+        })
+            .finally(() => {
+            if (this.inFlight === inFlight)
+                this.inFlight = null;
+        });
+        this.inFlight = inFlight;
+        return inFlight;
+    }
+}

package/dist/gui/server/market-state-api.d.ts

@@ -0,0 +1,250 @@
+import type Database from "better-sqlite3";
+import { searchYahooInstruments } from "../../market-state/resolve.js";
+import { MarketStateService } from "../../market-state/service.js";
+import { HISTORY_INTERVALS, type HISTORY_RANGES } from "../../tools/market/stock-history.js";
+type HistoryRange = (typeof HISTORY_RANGES)[number];
+type HistoryInterval = (typeof HISTORY_INTERVALS)[number];
+export interface ResolvedHistoryRange {
+    range: HistoryRange;
+    interval: HistoryInterval;
+}
+export interface InvalidHistoryRequest {
+    status: "invalid_request";
+    reason: string;
+}
+export interface InstrumentHistoryBar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export interface InstrumentHistorySnapshotOk {
+    status: "ok";
+    symbol: string;
+    range: string;
+    interval: HistoryInterval;
+    source: InstrumentHistorySource;
+    fetchedAt: string;
+    dataAsOf?: string;
+    stale: boolean;
+    prevClose: number | null;
+    bars: InstrumentHistoryBar[];
+}
+export interface InstrumentHistorySnapshotUnavailable {
+    status: "unavailable";
+    reason: string;
+    dataAsOf?: string;
+    stale?: boolean;
+}
+export type InstrumentHistorySnapshot = InstrumentHistorySnapshotOk | InstrumentHistorySnapshotUnavailable | InvalidHistoryRequest;
+type InstrumentHistorySource = "Yahoo Finance" | "Alpha Vantage" | "London Strategic Edge";
+export declare function resolveHistoryRange(rangeLabel: string, intervalOverride?: string): ResolvedHistoryRange | InvalidHistoryRequest;
+export declare function getInstrumentHistorySnapshot(symbol: string, rangeLabel?: string, intervalOverride?: string): Promise<InstrumentHistorySnapshot>;
+export declare function resetInstrumentHistoryMemoForTests(): void;
+export type MarketSparklineSnapshot = {
+    status: "ok";
+    source: "Yahoo Finance";
+    points: number[];
+    fetchedAt: string;
+    dataAsOf?: string;
+    stale: false;
+} | {
+    status: "unavailable";
+    source: "Yahoo Finance";
+    reason: string;
+    dataAsOf?: string;
+    stale?: boolean;
+};
+export interface MarketStateSnapshot {
+    instruments: Array<NonNullable<ReturnType<MarketStateService["getInstrument"]>>>;
+    watchlists: ReturnType<MarketStateService["listWatchlists"]>;
+    portfolios: ReturnType<MarketStateService["listPortfolios"]>;
+    watchlist: ReturnType<MarketStateService["listWatchlistItems"]>;
+    portfolio: ReturnType<MarketStateService["listPortfolioLots"]>;
+    alerts: ReturnType<MarketStateService["listAlertRules"]>;
+    alertEvents: ReturnType<MarketStateService["listAlertEvents"]>;
+    alertCheckRuns: ReturnType<MarketStateService["listAlertCheckRuns"]>;
+    reportTemplates: ReturnType<MarketStateService["listReportTemplates"]>;
+    reportRuns: ReturnType<MarketStateService["listReportRuns"]>;
+    runnerLease: ReturnType<MarketStateService["getAutomationRunnerLease"]>;
+    notifications: ReturnType<MarketStateService["listNotificationEvents"]>;
+    notificationDeliveryAttempts: ReturnType<MarketStateService["listNotificationDeliveryAttempts"]>;
+}
+export interface MarketStateQuoteSnapshot {
+    generatedAt: string;
+    watchlistQuotes: Array<{
+        itemId: number;
+        instrumentId: number;
+        symbol: string;
+        name?: string;
+        status: "ok" | "unavailable";
+        price?: number;
+        change?: number;
+        changePercent?: number;
+        volume?: number;
+        dayHigh?: number;
+        dayLow?: number;
+        week52High?: number;
+        week52Low?: number;
+        currency?: string | null;
+        fetchedAt?: string;
+        dataAsOf?: string;
+        marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+        extendedPrice?: number;
+        extendedChange?: number;
+        extendedChangePercent?: number;
+        extendedAsOf?: string;
+        stale?: boolean;
+        reason?: string;
+        sparkline: MarketSparklineSnapshot;
+    }>;
+    portfolioQuotes: Array<{
+        lotId: number;
+        portfolioId: number;
+        instrumentId: number;
+        symbol: string;
+        name?: string;
+        status: "ok" | "unavailable";
+        currentPrice?: number | null;
+        changePercent?: number;
+        marketValue?: number | null;
+        totalCost: number;
+        pnl?: number | null;
+        pnlPercent?: number | null;
+        allocationPercent?: number;
+        currency: string;
+        includedInTotals: boolean;
+        fetchedAt?: string;
+        dataAsOf?: string;
+        marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+        extendedPrice?: number;
+        extendedChange?: number;
+        extendedChangePercent?: number;
+        extendedAsOf?: string;
+        stale?: boolean;
+        reason?: string;
+        sparkline: MarketSparklineSnapshot;
+    }>;
+    portfolioSummary: {
+        portfolioId: number;
+        baseCurrency: string;
+        totalValue: number;
+        totalCost: number;
+        totalPnl: number;
+        totalPnlPercent: number;
+        excludedFromTotals: Array<{
+            symbol: string;
+            currency: string;
+            reason: string;
+        }>;
+    };
+    portfolioSummaries: Array<{
+        portfolioId: number;
+        baseCurrency: string;
+        totalValue: number;
+        totalCost: number;
+        totalPnl: number;
+        totalPnlPercent: number;
+        excludedFromTotals: Array<{
+            symbol: string;
+            currency: string;
+            reason: string;
+        }>;
+    }>;
+}
+interface SavedSymbolsMemoOptions {
+    ttlMs?: number;
+    now?: () => number;
+}
+export declare function createSavedSymbolsMemo(load: () => string[], options?: SavedSymbolsMemoOptions): () => string[];
+export declare const getSavedMarketStateSymbols: () => string[];
+export declare function buildMarketStateSnapshot(db?: Database.Database): MarketStateSnapshot;
+export declare function buildMarketStateQuoteSnapshot(db?: Database.Database): Promise<MarketStateQuoteSnapshot>;
+export declare function fetchSparklineSnapshot(symbol: string): Promise<MarketSparklineSnapshot>;
+export declare function searchInstrumentCandidates(query: string): Promise<{
+    query: string;
+    candidates: Awaited<ReturnType<typeof searchYahooInstruments>>;
+    error?: string;
+}>;
+export declare function getInstrumentQuoteSnapshot(symbol: string): Promise<{
+    symbol: string;
+    status: "ok";
+    name?: string;
+    price: number;
+    change: number;
+    changePercent: number;
+    volume: number;
+    high: number;
+    low: number;
+    week52High: number;
+    week52Low: number;
+    marketCap: number;
+    fetchedAt: string;
+    dataAsOf?: string;
+    marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+    extendedPrice?: number;
+    extendedChange?: number;
+    extendedChangePercent?: number;
+    extendedAsOf?: string;
+    stale: boolean;
+    currency: string | null;
+} | {
+    symbol: string;
+    status: "unavailable";
+    reason: string;
+}>;
+export type InstrumentOverviewSnapshot = {
+    symbol: string;
+    status: "ok";
+    name: string;
+    description: string;
+    exchange: string;
+    sector: string;
+    industry: string;
+    marketCap: number;
+    pe: number | null;
+    forwardPe: number | null;
+    eps: number | null;
+    dividendYield: number | null;
+    beta: number | null;
+    avgVolume: number;
+    profitMargin: number | null;
+    revenueGrowth: number | null;
+    week52High: number;
+    week52Low: number;
+    stale: boolean;
+} | {
+    symbol: string;
+    status: "unavailable";
+    reason: string;
+};
+export declare function getInstrumentOverviewSnapshot(symbol: string): Promise<InstrumentOverviewSnapshot>;
+export declare function resetInstrumentOverviewMemoForTests(): void;
+export declare function fetchQuoteSnapshot(symbol: string): Promise<{
+    status: "ok";
+    name?: string;
+    price: number;
+    change: number;
+    changePercent: number;
+    volume: number;
+    high: number;
+    low: number;
+    week52High: number;
+    week52Low: number;
+    marketCap: number;
+    fetchedAt: string;
+    dataAsOf?: string;
+    marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+    extendedPrice?: number;
+    extendedChange?: number;
+    extendedChangePercent?: number;
+    extendedAsOf?: string;
+    stale: boolean;
+    currency: string | null;
+} | {
+    status: "unavailable";
+    reason: string;
+}>;
+export {};